-- this module contains only constants for input and other things like that
local const      = require "lua modules/constants"
local gui_helper = require "lua modules/gui_helpers"
local lume       = require "lua modules/lume"

local madgui = { version = "0.0.1"}
madgui.__index = madgui

function madgui.create_gui_manager(table)
    return {
        in_focus = {},
        page_nodes = {},
        cursor_node = nil,
        cursor_pos = nil,
        window_width  = tonumber(sys.get_config("display.width")),
        window_height = tonumber(sys.get_config("display.height")),
        is_fullscreen = tonumber(sys.get_config("display.fullscreen")),
        mouse_sensitivity = tonumber(sys.get_config("default_settings.mouse_sensitivity"))}
end

function madgui.set_cursor(manager, cursor_node)
    manager.cursor_node = cursor_node
end

function madgui.hide_cursor(manager)
    if manager.cursor_node ~= nil then
        gui.set_enabled(manager.cursor_node, false)
    end
end

function madgui.show_cursor(manager)
    if manager.cursor_node ~= nil then
        gui.set_enabled(manager.cursor_node, true)
    end
end

--this affects only fullscreen mouse!
function madgui.set_mouse_sensitivity(manager, value)
    manager.mouse_sensitivity = lume.clamp(value, 0.0, 1.0)
end

function madgui.handle_manager_input(manager,action_id, action)
    if manager.cursor_node ~= nil then
        if manager.cursor_pos == nil then
            manager.cursor_pos = gui.get_position(manager.cursor_node)
        end
        if manager.is_fullscreen == 1 then
            manager.cursor_pos.x = lume.clamp(
                manager.cursor_pos.x + action.dx * manager.mouse_sensitivity,
                0, manager.window_width)

            manager.cursor_pos.y = lume.clamp(
                manager.cursor_pos.y + action.dy * manager.mouse_sensitivity,
                0, manager.window_height)
        else
            manager.cursor_pos.x = action.x
            manager.cursor_pos.y = action.y
        end

        gui.set_position(manager.cursor_node, manager.cursor_pos)
    end

    for i = 1, #manager.page_nodes do
        if gui_helper.is_node_enabled(manager.page_nodes[i].node) then
            madgui.handle_page_input(manager.page_nodes[i], action_id, action)
        end
    end
end

function madgui.add_page(manager, page_node, focus_node)
    local nd, page_id =
        lume.match(manager.page_nodes,
                   function(pg_node)
                       return pg_node.node == page_node
                   end)
    if page_id ~= nil then
        return nil
    end

    -- by default every page that have been added is disabled
    gui.set_enabled(page_node, false)
    local page = madgui.page(manager, page_node, focus_node)
    table.insert(manager.page_nodes, page)

    return page
end

function madgui.set_active_page_by_node(manager, page_node)
    for i = 1, #manager.page_nodes do
        gui.set_enabled(manager.page_nodes[i].node,
                        manager.page_nodes[i].node == page_node)
    end
    madgui.show_cursor(manager)
end

function madgui.hide_all_pages(manager)
    for i = 1, #manager.page_nodes do
        gui.set_enabled(manager.page_nodes[i].node, false)
    end
    madgui.hide_cursor(manager)
end

--
-- madgui_button
--
function madgui.button(manager,
                       page,
                       button_node,
                       button_callback,
                       horizontal_order,
                       ignore_on_vertical,
                       is_locking_to_right,
                       is_locking_to_left)
    gui.set_color(button_node, const.color_normal)
    return {
        manager             = manager,
        page                = page,
        node                = button_node,
        callback            = button_callback,
        horizontal_order    = horizontal_order,
        ignore_on_vertical  = ignore_on_vertical,
        clicked             = false,
        is_locking_to_right = is_locking_to_right,
        is_locking_to_left  = is_locking_to_left
    }
end

--function madgui.copy_button

function madgui.handle_button_input(button, action_id, action)
    if not gui_helper.is_node_enabled(button.node) then
        return
    end

    if button.manager.in_focus[button.node] == nil then
        button.manager.in_focus[button.node] = false
    end

    if button.manager.cursor_node == nil then
        return
    end

    if button.manager.cursor_pos == nil then
        return
    end

    if gui.pick_node(button.node, button.manager.cursor_pos.x, button.manager.cursor_pos.y) then
        if not button.manager.in_focus[button.node] then
            button.manager.in_focus[button.node] = true
            madgui.refocus_on(button.page, button.node)
            gui_helper.change_node_color_smooth(button.node, const.color_focused)
        end

        if (action_id == hash("touch")) then
            if action.pressed then
                gui.set_color(button.node, const.color_pressed)
                gui.set_color(button.page.focus, const.color_pressed)
                gui.set_scale(button.page.focus, const.scale_pressed)
                button.clicked = true
            elseif button.clicked and action.released then
                gui.set_color(button.node, const.color_focused)
                gui_helper.change_property_smooth(button.page.focus, gui.PROP_SCALE, const.scale_normal, 0.15)
                gui_helper.change_property_smooth(button.page.focus, gui.PROP_COLOR, const.color_white, 0.15)
                button.clicked = false
                button.callback()
            end
        end
    else
        if button.manager.in_focus[button.node] then
            gui_helper.change_property_smooth(button.page.focus, gui.PROP_SCALE, const.scale_normal, 0.15)
            gui_helper.change_property_smooth(button.page.focus, gui.PROP_COLOR, const.color_white, 0.15)

            button.manager.in_focus[button.node] = false
            gui_helper.change_node_color_smooth(button.node, const.color_normal)
        end
    end
end

--
-- madgui_page
--
function madgui.page(manager, page_node, focus_node)
    return {
    manager       = manager,
    node          = page_node,
    focus         = focus_node,
    focused       = nil,
    progress_bars = {},
    buttons       = {},
    buttons_hor   = {},
    enter_key_pressed = false,
    escape_key_pressed = false,
    on_escape = nil}
end

function madgui.add_button(page,
                           button_node,
                           callback,
                           horizontal_order,
                           ignore_on_vertical,
                           is_locking_to_right,
                           is_locking_to_left)
    local already_exists = false
    for i = 1, #page.buttons do
        if page.buttons[i].node == button_node then
            already_exists = true
            break
        end
    end

    if already_exists then
        return nil
    end

    local button = madgui.button(page.manager,
                                 page,
                                 button_node,
                                 callback,
                                 horizontal_order,
                                 ignore_on_vertical,
                                 is_locking_to_right,
                                 is_locking_to_left)
    table.insert(page.buttons, button)

    return button
end

function madgui.add_button_range(page, locked, starting_order, ...)
    local hor_order = starting_order
    local end_index = select("#", ...)
    for i = 1, select("#", ...) do
        local array_element = select(i, ...)
        madgui.add_button(page,
                          array_element.button_node,
                          array_element.callback,
                          hor_order,
                          false,
                          locked,
                          locked)
        hor_order = hor_order + 1
    end
end

function madgui.add_button_row(page, starting_order, central_node, ...)
    local hor_order = starting_order
    local end_index = select("#", ...)
    for i = 1, end_index do
        local array_element = select(i, ...)
        local ignore_vert = false
        if i == 1 then
            if central_node ~= nil then
                if central_node ~= array_element.button_node then
                    ignore_vert = true
                end
            end
            madgui.add_button(
                page,
                array_element.button_node,
                array_element.callback,
                hor_order,
                ignore_vert,
                false,
                true)
        else
            ignore_vert = true
            if central_node ~= nil then
                if central_node == array_element.button_node then
                    ignore_vert = false
                end
            end
            madgui.add_button(
                page,
                array_element.button_node,
                array_element.callback,
                hor_order,
                ignore_vert,
                i == end_index,
                false)
        end
        hor_order = hor_order + 1
    end
end

function madgui.abstract_refocus(page, new_focus_node, callback)
    if page.focus == nil then
        return
    end

    if not gui_helper.is_node_enabled(page.focus) then
        return
    end

    if not gui_helper.is_node_enabled(new_focus_node) then
        return
    end

    if (page.focused == nil) or
       (page.focused ~= new_focus_node)
    then
        local pos = gui.get_position(new_focus_node)
        local size = gui.get_size(new_focus_node)
        size.x = size.x + 10
        size.y = size.y + 10
        callback(page.focus, size, pos)
        page.focused = new_focus_node
    end
end

function madgui.refocus_on(page, node)
    madgui.abstract_refocus(page, node,
        function(node, new_size, new_position)
            gui_helper.change_node_size_smooth(node, new_size)
            gui_helper.change_node_position_smooth(node, new_position)
        end)
end

function madgui.refocus_on_immediate(page, node)
    madgui.abstract_refocus(page, node,
        function(node, new_size, new_position)
            gui.set_size(node, new_size)
            gui.set_position(node, new_position)
        end)
end

function madgui.add_on_escape_callback(page, callback)
    page.on_escape = callback
end

function madgui.handle_page_input(page, action_id, action)
    local is_prev_key = action_id == const.input_left
    local is_next_key = action_id == const.input_right
    local is_up_key   = action_id == const.input_up
    local is_down_key = action_id == const.input_down

    local is_controls = is_prev_key or is_next_key or is_up_key or is_down_key
    if is_controls then
        if #page.buttons_hor ~= #page.buttons then
            page.buttons_hor = lume.chain(page.buttons)
                :filter(lume.lambda "a -> a.horizontal_order > -1")
                :sort(lume.lambda "a,b -> a.horizontal_order <= b.horizontal_order")
                :result()
        end

        local next_focus = page.focused
        if page.focused == nil then
            if #page.buttons > 0 then
                next_focus = page.buttons[1].node
            end
        else
            if (is_next_key or is_prev_key) and action.released then
                local current_button, current_id =
                    lume.match(page.buttons_hor,
                               function(btn)
                                   return btn.node == page.focused
                               end)

                if current_id ~= nil then
                    if is_next_key then
                        if current_button.is_locking_to_right then
                            return
                        end
                        local next_id = current_id + 1
                        if next_id > #page.buttons_hor then
                            next_id = 1
                        end
                        while not gui_helper.is_node_enabled(page.buttons_hor[next_id].node) do
                            next_id = next_id + 1
                            if next_id > #page.buttons_hor then
                                next_id = 1
                            end
                            if next_id == current_id then break end
                        end
                        next_focus = page.buttons_hor[next_id].node
                    else
                        if current_button.is_locking_to_left then
                            return
                        end
                        local next_id = current_id - 1
                        if next_id < 1 then
                            next_id = #page.buttons_hor
                        end
                        while not gui_helper.is_node_enabled(page.buttons_hor[next_id].node) do
                            next_id = next_id - 1
                            if next_id < 1 then
                                next_id = #page.buttons_hor
                            end
                            if next_id == current_id then break end
                        end
                        next_focus = page.buttons_hor[next_id].node
                    end
                end
            elseif (is_down_key or is_up_key) and action.released then
                local current_button, current_id =
                    lume.match(page.buttons_hor,
                               function(btn)
                                   return btn.node == page.focused
                               end)

                if current_id ~= nil then
                    if is_down_key then
                        local additional_step_needed = false
                        if (current_button.ignore_on_vertical) and
                           (not current_button.is_locking_to_right)
                        then
                            additional_step_needed = true
                        end
                        local next_id = current_id + 1
                        if next_id > #page.buttons_hor then
                            next_id = 1
                        end
                        while (not gui_helper.is_node_enabled(page.buttons_hor[next_id].node)) or
                              page.buttons_hor[next_id].ignore_on_vertical
                        do
                            next_id = next_id + 1
                            if next_id > #page.buttons_hor then
                                next_id = 1
                            end
                            if next_id == current_id then break end
                        end

                        if additional_step_needed then
                            additional_step_needed = false
                            next_id = next_id - 1
                            if next_id > #page.buttons_hor then
                                next_id = 1
                            end
                            while (not gui_helper.is_node_enabled(page.buttons_hor[next_id].node)) or
                                  page.buttons_hor[next_id].ignore_on_vertical
                            do
                                next_id = next_id + 1
                                if next_id > #page.buttons_hor then
                                    next_id = 1
                                end
                                if next_id == current_id then break end
                            end
                        end

                        next_focus = page.buttons_hor[next_id].node
                    else
                        local additional_step_needed = false
                        if (current_button.ignore_on_vertical) and
                           (not current_button.is_locking_to_left)
                        then
                            additional_step_needed = true
                        end
                        local next_id = current_id - 1
                        if next_id < 1 then
                            next_id = #page.buttons_hor
                        end
                        while (not gui_helper.is_node_enabled(page.buttons_hor[next_id].node)) or
                              page.buttons_hor[next_id].ignore_on_vertical
                        do
                            next_id = next_id - 1
                            if next_id < 1 then
                                next_id = #page.buttons_hor
                            end
                            if next_id == current_id then break end
                        end

                        if additional_step_needed then
                            additional_step_needed = false
                            next_id = next_id - 1
                            if next_id < 1 then
                                next_id = #page.buttons_hor
                            end
                            while (not gui_helper.is_node_enabled(page.buttons_hor[next_id].node)) or
                                  page.buttons_hor[next_id].ignore_on_vertical
                            do
                                next_id = next_id - 1
                                if next_id < 1 then
                                    next_id = #page.buttons_hor
                                end
                                if next_id == current_id then break end
                            end
                        end

                        next_focus = page.buttons_hor[next_id].node
                    end
                end
            end
        end
        if next_focus ~= nil then
            madgui.refocus_on(page, next_focus)
        end

        return
    elseif (action_id == const.input_reload) and action.pressed then
        page.enter_key_pressed = true
        gui.set_color(page.focus, const.color_pressed)
        gui.set_scale(page.focus, const.scale_pressed)
    elseif (action_id == const.input_reload) and page.enter_key_pressed and action.released then
        page.enter_key_pressed = false
        gui_helper.change_property_smooth(page.focus, gui.PROP_SCALE, const.scale_normal, 0.15)
        gui_helper.change_property_smooth(page.focus, gui.PROP_COLOR, const.color_white, 0.15)

        if page.focused == nil then
            page.focused = page.buttons[1].node
        end
        local current_id = nil
        for i = 1, #page.buttons do
            if page.buttons[i].node == page.focused then
                current_id = i
                break
            end
        end

        if current_id ~= nil then
            page.buttons[current_id].callback()
        end
    elseif (page.on_escape ~= nil) and
           (action_id == const.input_escape) and
           action.pressed
    then
        page.escape_key_pressed = true
    elseif (page.on_escape ~= nil) and
           (action_id == const.input_escape) and
           page.escape_key_pressed and
           action.released
    then
        page.on_escape()
    end

    for i = 1, #page.buttons do
        madgui.handle_button_input(page.buttons[i], action_id, action)
    end
end

function madgui.activate(page)
    madgui.set_active_page_by_node(page.manager, page.node)
end

function madgui.progress_bar(mask_node,
                             min_value,
                             initial_value,
                             step)
    gui_helper.slide_clipping_mask_on_alpha_immediate(mask_node, initial_value)
    return {
        mask_node = mask_node,
        min_value = math.max(0.0, min_value),
        progress  = lume.clamp(initial_value, math.max(0.0, min_value), 1.0),
        step      = step
    }
end

function madgui.set_progress(progress_bar, value)
    progress_bar.progress = lume.clamp(value, progress_bar.min_value, 1.0)
    gui_helper.slide_clipping_mask_on_alpha(progress_bar.mask_node,
                                            progress_bar.progress)
end

function madgui.set_progress_immediate(progress_bar, value)
    progress_bar.progress = lume.clamp(value, progress_bar.min_value, 1.0)
    gui_helper.slide_clipping_mask_on_alpha_immediate(progress_bar.mask_node,
                                                      progress_bar.progress)
end

function madgui.increase_progress(progress_bar)
    madgui.set_progress(progress_bar, progress_bar.progress + progress_bar.step)
end

function madgui.decrease_progress(progress_bar)
    madgui.set_progress(progress_bar, progress_bar.progress - progress_bar.step)
end

return madgui