local machi = {
    layout = require((...):match("(.-)[^%.]+$") .. "layout"),
    engine = require((...):match("(.-)[^%.]+$") .. "engine"),
}

local capi = {
    client = client,
    screen = screen,
}

local beautiful = require("beautiful")
local wibox = require("wibox")
local awful = require("awful")
local gears = require("gears")
local lgi = require("lgi")
local dpi = require("beautiful.xresources").apply_dpi
local gtimer = require("gears.timer")

local ERROR = 2
local WARNING = 1
local INFO = 0
local DEBUG = -1

local module = {
    log_level = WARNING,
}

local function log(level, msg)
    if level > module.log_level then
        print(msg)
    end
end

local function min(a, b)
    if a < b then return a else return b end
end

local function max(a, b)
    if a < b then return b else return a end
end

local function with_alpha(col, alpha)
    local r, g, b
    _, r, g, b, _ = col:get_rgba()
    return lgi.cairo.SolidPattern.create_rgba(r, g, b, alpha)
end

function module.start(c, exit_keys)
    local tablist_font_desc = beautiful.get_merged_font(
        beautiful.font, dpi(10))
    local font_color = with_alpha(gears.color(beautiful.fg_normal), 1)
    local font_color_hl = with_alpha(gears.color(beautiful.fg_focus), 1)
    local label_size = dpi(30)
    local border_color = with_alpha(
        gears.color(beautiful.machi_switcher_border_color or beautiful.border_focus),
        beautiful.machi_switcher_border_opacity or 0.25)
    local border_color_hl = with_alpha(
        gears.color(beautiful.machi_switcher_border_hl_color or beautiful.border_focus),
        beautiful.machi_switcher_border_hl_opacity or 0.75)
    local fill_color = with_alpha(
        gears.color(beautiful.machi_switcher_fill_color or beautiful.bg_normal),
        beautiful.machi_switcher_fill_opacity or 0.25)
    local box_bg = with_alpha(
        gears.color(beautiful.machi_switcher_box_bg or beautiful.bg_normal),
        beautiful.machi_switcher_box_opacity or 0.85)
    local fill_color_hl = with_alpha(
        gears.color(beautiful.machi_switcher_fill_color_hl or beautiful.bg_focus),
        beautiful.machi_switcher_fill_hl_opacity or 1)
    -- for comparing floats
    local threshold = 0.1
    local traverse_radius = dpi(5)

    local screen = c and c.screen or awful.screen.focused()
    local tag = screen.selected_tag
    local layout = tag.layout
    local gap = tag.gap
    local start_x = screen.workarea.x
    local start_y = screen.workarea.y

    if layout.machi_get_instance_data == nil then return end

    local cd, td, areas, _new_placement_cb = layout.machi_get_instance_data(screen, screen.selected_tag)
    if areas == nil or #areas == 0 then
        return
    end

    local infobox, infotabbox
    local tablist = nil

    local traverse_x, traverse_y
    if c then
        traverse_x = c.x + traverse_radius
        traverse_y = c.y + traverse_radius
    else
        traverse_x = screen.workarea.x + screen.workarea.width / 2
        traverse_y = screen.workarea.y + screen.workarea.height / 2
    end

    local selected_area_ = nil
    local function set_selected_area(area)
        selected_area_ = area
        if area then
            traverse_x = max(areas[area].x + traverse_radius, min(areas[area].x + areas[area].width - traverse_radius, traverse_x))
            traverse_y = max(areas[area].y + traverse_radius, min(areas[area].y + areas[area].height - traverse_radius, traverse_y))
        end
    end

    local function selected_area()
        if selected_area_ == nil then
            local min_dis = nil
            for i, a in ipairs(areas) do
                if a.habitable then
                    local dis =
                        math.abs(a.x + traverse_radius - traverse_x) + math.abs(a.x + a.width - traverse_radius - traverse_x) - a.width +
                        math.abs(a.y + traverse_radius - traverse_y) + math.abs(a.y + a.height - traverse_radius - traverse_y) - a.height +
                        traverse_radius * 4
                    if min_dis == nil or min_dis > dis then
                        min_dis = dis
                        selected_area_ = i
                    end
                end
            end

            set_selected_area(selected_area_)
        end
        return selected_area_
    end

    local parent_stack = {}

    local function get_tablist(area)
        local list = {}
        for _, tc in ipairs(screen.tiled_clients) do
            if not (tc.floating or tc.immobilized)
            then
                if areas[area].x <= tc.x + tc.width + tc.border_width * 2 and tc.x <= areas[area].x + areas[area].width and
                    areas[area].y <= tc.y + tc.height + tc.border_width * 2 and tc.y <= areas[area].y + areas[area].height
                then
                    list[#list + 1] = tc
                end
            end
        end

        return list
    end

    local function maintain_tablist()
        tablist = get_tablist(selected_area())
        if #tablist ~= 0 then
            c = tablist[1]
        end
    end

    local function draw_tab_info(context, cr, width, height)
        maintain_tablist()

        local wi = { x = 0, y = 0, w = 1, h = 1 }
        local ext
        local active_area = selected_area()
        if #tablist > 0 then
            local a = areas[active_area]
            local pl = lgi.Pango.Layout.create(cr)
            pl:set_font_description(tablist_font_desc)

            local vpadding = dpi(10)
            local hpadding = dpi(15)
            local vborder  = dpi(5)
            local hborder  = dpi(5)
            local list_height = 2 * vborder
            local list_width = 2 * hpadding + 2 * hborder
            local exts = {}

            local tl = {}
            local hw = math.floor((#tablist-1)/2)
            for i = hw+1,2,-1 do
                table.insert(tl, tablist[i])
            end
            table.insert(tl, tablist[1])
            local active = #tl
            for i = #tablist,hw+2,-1 do
                table.insert(tl, tablist[i])
            end

            for index, tc in ipairs(tl) do
                local label = tc.name or "<unnamed>"
                pl:set_text(label)
                local w, h
                w, h = pl:get_size()
                w = w / lgi.Pango.SCALE
                h = h / lgi.Pango.SCALE
                local ext = { width = w, height = h }
                exts[#exts + 1] = ext
                list_height = list_height + ext.height + vpadding
                list_width = max(list_width, w + 2 * hpadding + 2 * hborder)
            end

            local y_offset = vborder
            wi.x = a.x + (a.width - list_width) / 2
            wi.y = a.y + (a.height - list_height) / 2
            wi.w = list_width
            wi.h = list_height

            cr:rectangle(0, 0, list_width, list_height)
            cr:set_source(border_color_hl)
            cr:fill()

            for index, tc in ipairs(tl) do
                local label = tc.name or "<unnamed>"
                local ext = exts[index]
                if index == active then
                    cr:rectangle(hborder, y_offset, list_width - 2 * hborder, ext.height + vpadding)
                    cr:set_source(fill_color_hl)
                    cr:fill()
                    pl:set_text(label)
                    cr:move_to(hborder + hpadding, vpadding / 2 + y_offset)
                    cr:set_source(font_color_hl)
                    cr:show_layout(pl)
                else
                    pl:set_text(label)
                    cr:move_to(hborder + hpadding, vpadding / 2 + y_offset)
                    cr:set_source(font_color)
                    cr:show_layout(pl)
                end

                y_offset = y_offset + ext.height + vpadding
            end
        end

        if infotabbox.x ~= wi.x or infotabbox.y ~= wi.y or
            infotabbox.width ~= wi.w or infotabbox.height ~= wi.h
        then
            infotabbox.x = wi.x
            infotabbox.y = wi.y
            infotabbox.width = wi.w
            infotabbox.height = wi.h
        end
    end

    local function draw_info(context, cr, width, height)
        maintain_tablist()

        cr:set_source_rgba(0, 0, 0, 0)
        cr:rectangle(0, 0, width, height)
        cr:fill()

        local padx = 5
        local pady = 5
        local msg
        local active_area = selected_area()
        for i, a in ipairs(areas) do
            if a.habitable or i == active_area then
                cr:rectangle(a.x - padx - start_x, a.y - pady - start_y, a.width + 2*padx, a.height + 2*pady)
                cr:clip()
                cr:set_source(fill_color)
                cr:rectangle(a.x - start_x, a.y - start_y, a.width, a.height)
                cr:fill()
                cr:set_source(i == active_area and border_color_hl or border_color)
                cr:rectangle(a.x - start_x, a.y - start_y, a.width, a.height)
                cr:set_line_width(10.0)
                cr:stroke()
                cr:reset_clip()
            end
        end

        if infobox.width ~= screen.workarea.width or infobox.height ~= screen.workarea.height then
            gtimer.delayed_call(function ()
                infobox.width = screen.workarea.width
                infobox.height = screen.workarea.height
                infobox.visible = true
            end)
        end

        -- show the traverse point
        -- cr:rectangle(traverse_x - start_x - traverse_radius, traverse_y - start_y - traverse_radius, traverse_radius * 2, traverse_radius * 2)
        -- cr:set_source_rgba(1, 1, 1, 1)
        -- cr:fill()
    end

    local draw = function()
        if infobox ~= nil then
            infobox.bgimage = draw_info
        end
        if infotabbox ~= nil then
            infotabbox.bgimage = draw_tab_info
        end
    end

    local largest_area = function(areas)
        local largest = nil
        local size = 0
        for i, a in ipairs(areas) do
            local s = a.width * a.height
            if a.habitable and (largest == nil or s > size) then
                largest = i
                size = s
            end
        end

        return largest
    end

    local snap_area = function(x, y, width, height)
        local bestD, d
        local best
        local dist = function(x0, y0, x1, y1)
            local a, b = x0-x1, y0-y1
            return math.sqrt(a*a+b*b)
        end
        for i, a in ipairs(areas) do
            d = dist(a.x, a.y, x, y) +
                dist(a.x+a.width, a.y+a.height, x+width, y+height)
            if bestD == nil or d < bestD then
                bestD = d
                best = i
            end
        end

        return best
    end


    -- area is the index in areas, should be made consistent after el big refactor
    -- draft is reset
    local move_client
    move_client = function(c, area)
        if area == nil or areas[area] == nil or c == nil or not c.valid or c.floating then
            return
        end
        machi.layout.set_geometry(c, areas[area], areas[area], 0, c.border_width)
        if cd[c] == nil then
            return
        end
        cd[c].lu = nil
        cd[c].rd = nil
        cd[c].area = area
    end

    local snap_client = function()
        if c == nil then
            return
        end
        a = snap_area(c.x, c.y, c.width, c.height)
        if a == nil then
            return false
        end

        move_client(c, a)
        return true
    end

    local master_add = function()
        if c == nil or c.floating then
            return
        end

        local dst = largest_area(areas)
        if dst == nil then
            return
        end
        move_client(c, dst)
        awful.layout.arrange(screen)
    end

    local master_swap = function(all)
        if c == nil or c.floating then
            return
        end

        local src = selected_area()
        local dst = largest_area(areas)
        if dst == nil or dst == src then
            return
        end
        local srclist = get_tablist(src)
        local dstlist = get_tablist(dst)

        for i, c in ipairs(dstlist) do
            if all or i == 1 then
                move_client(c, src)
            end
        end
        for i, c in ipairs(srclist) do
            if all or i == 1 then
                move_client(c, dst)
            end
        end
        awful.layout.arrange(screen)
    end

    local traverse_clients = function(dir)
        dir = string.lower(dir)
        local current_area = selected_area()
        local current = areas[current_area]
        if current == nil then
            return false
        end

        local candidates = {}
        for i, a in ipairs(areas) do
            local data = {i = i, a = a}
            if not a.habitable or i == current_area then
            elseif dir == "up" and
                a.y + a.height < current.y and
                #get_tablist(i) ~= 0 then
                table.insert(candidates, data)
            elseif dir == "down" and
                a.y > current.y + current.height and
                #get_tablist(i) ~= 0 then
                table.insert(candidates, data)
            elseif dir == "left" and
                a.x + a.width < current.x and
                #get_tablist(i) ~= 0 then
                table.insert(candidates, data)
            elseif dir == "right" and
                a.x > current.x + current.width and
                #get_tablist(i) ~= 0 then
                table.insert(candidates, data)
            end
        end

        local best_area
        local score
        for i, d in ipairs(candidates) do
            local a = d.a
            local dist, overlap

            if dir == "up" or dir == "down" then
                overlap = min(current.x+current.width, a.x+a.width) - max(current.x, a.x)
            elseif dir == "left" or dir == "right" then
                overlap = min(current.y+current.height, a.y+a.height) - max(current.y, a.y)
            end

            if dir == "up" then
                dist = current.y - a.y - a.height
            elseif dir == "down" then
                dist = a.y - current. y - current.height
            elseif dir == "left" then
                dist = current.x - a.x - a.width
            elseif dir == "right" then
                dist = a.x - current.x - current.width
            end

            -- TODO this is probably not optimal
            local s = overlap - dist
            if score == nil or s > score then
                best_area = d.i
                score = s
            end
        end

        if best_area == nil then
            if #candidates == 0 then
                return false
            end
            best_area = candidates[1].i
        end

        set_selected_area(best_area)
        local tablist = get_tablist(best_area)
        if #tablist == 0 or tablist[1] == c then
            return false
        end
        c = tablist[1]
        capi.client.focus = c
        return true
    end

    local traverse_areas = function(dir, move, draft)
        dir = string.lower(dir)
        local current_area = selected_area()

        if c and move then
            if current_area == nil or
                areas[current_area].x ~= c.x or
                areas[current_area].y ~= c.y
            then
                traverse_x = c.x + traverse_radius
                traverse_y = c.y + traverse_radius
                set_selected_area(nil)
            end
        elseif c and draft then
            local ex = c.x + c.width + c.border_width * 2
            local ey = c.y + c.height + c.border_width * 2
            if current_area == nil or
                areas[current_area].x + areas[current_area].width ~= ex or
                areas[current_area].y + areas[current_area].height ~= ey
            then
                traverse_x = ex - traverse_radius
                traverse_y = ey - traverse_radius
                set_selected_area(nil)
            end
        end

        local choice = nil
        local choice_value

        current_area = selected_area()

        for i, a in ipairs(areas) do
            if not a.habitable then goto continue end

            local v
            if dir == "up" then
                if a.x < traverse_x + threshold
                    and traverse_x < a.x + a.width + threshold then
                    v = traverse_y - a.y - a.height
                else
                    v = -1
                end
            elseif dir == "down" then
                if a.x < traverse_x + threshold
                    and traverse_x < a.x + a.width + threshold then
                    v = a.y - traverse_y
                else
                    v = -1
                end
            elseif dir == "left" then
                if a.y < traverse_y + threshold
                    and traverse_y < a.y + a.height + threshold then
                    v = traverse_x - a.x - a.width
                else
                    v = -1
                end
            elseif dir == "right" then
                if a.y < traverse_y + threshold
                    and traverse_y < a.y + a.height + threshold then
                    v = a.x - traverse_x
                else
                    v = -1
                end
            end

            if (v > threshold) and (choice_value == nil or choice_value > v) then
                choice = i
                choice_value = v
            end
            ::continue::
        end

        if choice == nil then
            choice = current_area
            if dir == "up" then
                traverse_y = screen.workarea.y
            elseif dir == "down" then
                traverse_y = screen.workarea.y + screen.workarea.height
            elseif dir == "left" then
                traverse_x = screen.workarea.x
            else
                traverse_x = screen.workarea.x + screen.workarea.width
            end
        end

        if choice ~= nil then
            tablist = nil
            set_selected_area(choice)

            if c and draft and cd[c].draft ~= false then
                local lu = cd[c].lu or cd[c].area
                local rd = cd[c].rd or cd[c].area

                if draft and move then
                    lu = choice
                    if areas[rd].x + areas[rd].width <= areas[lu].x or
                        areas[rd].y + areas[rd].height <= areas[lu].y
                    then
                        rd = nil
                    end
                else
                    rd = choice
                    if areas[rd].x + areas[rd].width <= areas[lu].x or
                        areas[rd].y + areas[rd].height <= areas[lu].y
                    then
                        lu = nil
                    end
                end

                if lu ~= nil and rd ~= nil then
                    machi.layout.set_geometry(c, areas[lu], areas[rd], 0, c.border_width)
                elseif lu ~= nil then
                    machi.layout.set_geometry(c, areas[lu], nil, 0, c.border_width)
                elseif rd ~= nil then
                    c.x = min(c.x, areas[rd].x)
                    c.y = min(c.y, areas[rd].y)
                    machi.layout.set_geometry(c, nil, areas[rd], 0, c.border_width)
                end

                if lu == rd and cd[c].draft ~= true then
                    cd[c].lu = nil
                    cd[c].rd = nil
                    cd[c].area = lu
                else
                    cd[c].lu = lu
                    cd[c].rd = rd
                    cd[c].area = nil
                end

                c:emit_signal("request::activate", "mouse.move", {raise=false})
                c:raise()
                awful.layout.arrange(screen)
            elseif c and move then
                -- move the window
                local in_draft = cd[c].draft
                if cd[c].draft ~= nil then
                    in_draft = cd[c].draft
                elseif cd[c].lu then
                    in_draft = true
                elseif cd[c].area then
                    in_draft = false
                else
                    log(ERROR, "Assuming in_draft for unhandled client "..tostring(c))
                    in_draft = true
                end
                if in_draft then
                    c.x = areas[choice].x
                    c.y = areas[choice].y
                else
                    machi.layout.set_geometry(c, areas[choice], areas[choice], 0, c.border_width)
                    cd[c].lu = nil
                    cd[c].rd = nil
                    cd[c].area = choice
                end
                c:emit_signal("request::activate", "mouse.move", {raise=false})
                c:raise()
                awful.layout.arrange(screen)

                tablist = nil
            else
                maintain_tablist()
                -- move the focus
                if #tablist > 0 and tablist[1] ~= c then
                    c = tablist[1]
                    capi.client.focus = c
                end
            end

            draw()
        end
    end

    local tab = function()
        maintain_tablist()
        if #tablist > 1 then
            c = tablist[#tablist]
            c:emit_signal("request::activate", "mouse.move", {raise=false})
            c:raise()

            draw()
        end
    end

    local function handle_key(mod, key, event)
        local key_translate_tab = {
            ["k"] = "Up",
            ["h"] = "Left",
            ["j"] = "Down",
            ["l"] = "Right",
            ["K"] = "Up",
            ["H"] = "Left",
            ["J"] = "Down",
            ["L"] = "Right",
        }

        if event == "release" then
            if exit_keys and exit_keys[key] then
                exit()
            end
            return
        end
        if key_translate_tab[key] ~= nil then
            key = key_translate_tab[key]
        end

        maintain_tablist()
        assert(tablist ~= nil)

        local super = false
        local shift = false
        local ctrl = false
        for i, m in ipairs(mod) do
            if m == "Mod4" then super = true
            elseif m == "Shift" then shift = true
            elseif m == "Control" then ctrl = true
            end
        end

        if key == "Tab" then
            tab()
        elseif key == "Up" or key == "Down" or key == "Left" or key == "Right" then
            traverse_areas(key, shift or super, ctrl)
        elseif (key == "q" or key == "Prior") then
            local current_area = selected_area()
            if areas[current_area].parent_id == nil then
                return
            end

            set_selected_area(areas[current_area].parent_id)
            if #parent_stack == 0 or
                parent_stack[#parent_stack] ~= current_area then
                parent_stack = {current_area}
            end
            parent_stack[#parent_stack + 1] = areas[current_area].parent_id
            current_area = parent_stack[#parent_stack]

            if c and ctrl and cd[c].draft ~= false then
                if cd[c].area then
                    cd[c].lu, cd[c].rd, cd[c].area = cd[c].area, cd[c].area, nil
                end
                machi.layout.set_geometry(c, areas[current_area], areas[current_area], 0, c.border_width)
                awful.layout.arrange(screen)
            end

            draw()
        elseif (key =="e" or key == "Next") then
            local current_area = selected_area()
            if #parent_stack <= 1 or parent_stack[#parent_stack] ~= current_area then
                return
            end

            set_selected_area(parent_stack[#parent_stack - 1])
            table.remove(parent_stack, #parent_stack)
            current_area = parent_stack[#parent_stack]

            if c and ctrl then
                if areas[current_area].habitable and cd[c].draft ~= true then
                    cd[c].lu, cd[c].rd, cd[c].area = nil, nil, current_area
                end
                machi.layout.set_geometry(c, areas[current_area], areas[current_area], 0, c.border_width)
                awful.layout.arrange(screen)
            end

            draw()
        elseif key == "/" then
            local current_area = selected_area()
            local original_cmd = machi.engine.areas_to_command(areas, true, current_area)
            areas[current_area].hole = true
            local prefix, suffix = machi.engine.areas_to_command(
                areas, false):match("(.*)|(.*)")
            areas[current_area].hole = nil

            workarea = {
                x = areas[current_area].x - gap * 2,
                y = areas[current_area].y - gap * 2,
                width = areas[current_area].width + gap * 4,
                height = areas[current_area].height + gap * 4,
            }
            gtimer.delayed_call(
                function ()
                    layout.machi_editor.start_interactive(
                        screen,
                        {
                            workarea = workarea,
                            original_cmd = original_cmd,
                            cmd_prefix = prefix,
                            cmd_suffix = suffix,
                        }
                    )
                end
            )
            exit()
        elseif (key == "f" or key == ".") and c then
            if cd[c].draft == nil then
                cd[c].draft = true
            elseif cd[c].draft == true then
                cd[c].draft = false
            else
                cd[c].draft = nil
            end
            awful.layout.arrange(screen)
        elseif key == "Escape" or key == "Return" then
            exit()
        else
            log(DEBUG, "Unhandled key " .. key)
        end
    end

    local ui = function()
        infobox = wibox({
                screen = screen,
                x = screen.workarea.x,
                y = screen.workarea.y,
                width = 1, -- screen.workarea.width,
                height = 1, --screen.workarea.height,
                bg = "#ffffff00",
                opacity = 1,
                ontop = false,
                type = "normal",
        })
        infotabbox = wibox({
                screen = screen,
                x = screen.workarea.x,
                y = screen.workarea.y,
                width = 1,
                height = 1,
                bg = "#ffffff00",
                ontop = true,
                type = "normal",
                visible = true,
        })

        draw()

        awful.client.focus.history.disable_tracking()
        local kg
        local function exit()
            awful.client.focus.history.enable_tracking()
            if capi.client.focus then
                capi.client.emit_signal("focus", capi.client.focus)
            end
            infobox.visible = false
            infotabbox.visible = false
            awful.keygrabber.stop(kg)
        end

        kg = awful.keygrabber.run(
            function (...)
                ok, _ = pcall(handle_key, ...)
                if not ok then exit() end
            end
        )
    end

    return {
        ui = ui,
        tab = tab,
        snap_client = snap_client,
        master_add = master_add,
        --- swap current window with 'master' or moves it to the master position if it's unoccupied (i.e.: largest area/client)
        -- @param all      swap/move all clients in both areas, not just the top ones.
        master_swap = master_swap,
        --- focus client by direction
        -- @param dir      direction (up|right|down|left)
        -- @returns true if a client was found
        traverse_clients = traverse_clients,
        traverse_areas = traverse_areas,
        move = function(dir) traverse_areas(dir, true, false) end,
        -- like traverse_clients, returns true if a client was found
        focus = function(dir) return traverse_clients(dir) end,
    }
end

return module