local const      = require "lua modules/constants"
local madgui     = require "lua modules/madgui"
local gui_helper = require "lua modules/gui_helpers"

local function save_settings(self)
    local focused_difficulty = self.focus_boxed[self.difficulty_selection]
    local focused_control = self.focus_boxed[self.controls_selection]
    local settings_table = {
        selected_difficulty = self.difficulty_as_text[focused_difficulty],
        selected_controls = self.controls_as_text[focused_control],
        mouse_sensitivity = self.sensitivity_progress_bar.progress
    }

    local my_file_path = sys.get_save_file("snake_tut", "settings")
    print(my_file_path)
    if not sys.save(my_file_path, settings_table) then
        print("can't save!")
    end
end

function load_settings(self)
    local my_file_path = sys.get_save_file("snake_tut", "settings")
    local settings_table = sys.load(my_file_path)
    if not next(settings_table) then
        print("table is empty")
        return
    end

    if settings_table.selected_difficulty == "easy_input" then
        gui_helper.refocus_on_immediate(self,
            self.difficulty_selection,
            self.easy_input,
            self.color_lookup)
    elseif settings_table.selected_difficulty == "normal_input" then
        gui_helper.refocus_on_immediate(self,
            self.difficulty_selection,
            self.normal_input,
            self.color_lookup)
    else
        gui_helper.refocus_on_immediate(self,
            self.difficulty_selection,
            self.hard_input,
            self.color_lookup)
    end

    if settings_table.selected_controls == "std_input" then
        gui_helper.refocus_on_immediate(self,
            self.controls_selection,
            self.std_input,
            nil)
    else
        gui_helper.refocus_on_immediate(self,
            self.controls_selection,
            self.two_btn_input,
            nil)
    end

    if settings_table.mouse_sensitivity ~= nil then
        madgui.set_mouse_sensitivity(self.gui_manager,
                                     settings_table.mouse_sensitivity)
        madgui.set_progress_immediate(self.sensitivity_progress_bar,
                            settings_table.mouse_sensitivity)
    end
end

local function start_level(self, lvl)
    save_settings(self)
    msg.post("main:/loader#loader",
             "start_game",
             {level = lvl})
end

function init(self)
    msg.post(".", "acquire_input_focus")

    self.settings_node   = gui.get_node(hash("settings"))
    self.main_menu_node  = gui.get_node(hash("main_menu"))
    self.level_menu_node = gui.get_node(hash("level_menu"))

    self.level_menu_lvl1  = gui.get_node(hash("level_menu_lvl1"))
    self.level_menu_lvl2  = gui.get_node(hash("level_menu_lvl2"))
    self.level_menu_lvl3  = gui.get_node(hash("level_menu_lvl3"))
    self.level_menu_back  = gui.get_node(hash("level_menu_back"))
    self.level_menu_focus = gui.get_node(hash("level_menu_focus"))

    self.main_menu_play     = gui.get_node(hash("main_menu_play"))
    self.main_menu_settings = gui.get_node(hash("main_menu_settings"))
    self.main_menu_quit     = gui.get_node(hash("main_menu_quit"))

    self.std_input        = gui.get_node(hash("std_input"))
    self.two_btn_input    = gui.get_node(hash("two_btn_input"))
    self.easy_input       = gui.get_node(hash("easy_input"))
    self.normal_input     = gui.get_node(hash("normal_input"))
    self.hard_input       = gui.get_node(hash("hard_input"))
    self.sensitivity_down = gui.get_node(hash("sensitivity_down"))
    self.sensitivity_up   = gui.get_node(hash("sensitivity_up"))
    self.back_input       = gui.get_node(hash("back_input"))

    self.difficulty_selection = gui.get_node(hash("difficulty_selection"))
    self.controls_selection   = gui.get_node(hash("controls_selection"))
    self.focus                = gui.get_node(hash("focus"))
    self.main_menu_focus      = gui.get_node(hash("main_menu_focus"))

    self.cursor_node          = gui.get_node(hash("cursor"))

    self.sensitivity_slider_visual = gui.get_node(hash("sensitivity_slider_visual"))

    self.controls_as_text = {
        [self.std_input]     = "std_input",
        [self.two_btn_input] = "two_btn_input"
    }

    self.difficulty_as_text = {
        [self.easy_input]   = "easy_input",
        [self.normal_input] = "normal_input",
        [self.hard_input]   = "hard_input"
    }

    self.color_lookup = {
        [self.easy_input]   = {
            normal = const.color_green,
            intense = const.color_green_intense},
        [self.normal_input] = {
            normal = const.color_yellow,
            intense = const.color_yellow_intense},
        [self.hard_input]   = {
            normal = const.color_red,
            intense = const.color_red_intense}
    }

    self.gui_manager = madgui.create_gui_manager()
    madgui.set_cursor(self.gui_manager, self.cursor_node)
    madgui.set_mouse_sensitivity(self.gui_manager, 0.4)
    self.sensitivity_progress_bar =
        madgui.progress_bar(self.sensitivity_slider_visual,
                            0.1, 0.4, 0.1)

    self.settings_page = madgui.add_page(self.gui_manager,
                                         self.settings_node,
                                         self.focus)
    madgui.add_on_escape_callback(self.settings_page,
                                  function()
                                      madgui.activate(self.main_menu_page)
                                  end)

    local chg_difficulty_selection =
        function(new_node)
            gui_helper.refocus_on_immediate(self.focus_boxed,
                                            self.difficulty_selection,
                                            new_node, self.color_lookup)
        end

    local chg_controls_selection =
        function(new_node)
            gui_helper.refocus_on_immediate(self.focus_boxed,
                                            self.controls_selection,
                                            new_node, nil)
        end

    madgui.add_button_row(self.settings_page, 1, nil,
        { button_node = self.easy_input,
          callback = function() chg_difficulty_selection(self.easy_input) end},
        { button_node = self.normal_input,
          callback = function() chg_difficulty_selection(self.normal_input) end},
        { button_node = self.hard_input,
          callback = function() chg_difficulty_selection(self.hard_input) end})

    madgui.add_button_row(self.settings_page, 4, nil,
        { button_node = self.std_input,
          callback = function() chg_controls_selection(self.std_input) end},
        { button_node = self.two_btn_input,
          callback = function() chg_controls_selection(self.two_btn_input) end})

    madgui.add_button_row(self.settings_page, 6, nil,
        { button_node = self.sensitivity_down,
          callback = function()
              madgui.decrease_progress(self.sensitivity_progress_bar)
              madgui.set_mouse_sensitivity(self.gui_manager,
                  self.sensitivity_progress_bar.progress)
          end},
        { button_node = self.sensitivity_up,
          callback = function()
              madgui.increase_progress(self.sensitivity_progress_bar)
              madgui.set_mouse_sensitivity(self.gui_manager,
                  self.sensitivity_progress_bar.progress)
          end})

    madgui.add_button_range(self.settings_page, true, 8,
        { button_node = self.back_input,
          callback = function()
              madgui.activate(self.main_menu_page)
          end})

    self.main_menu_page = madgui.add_page(self.gui_manager,
                                          self.main_menu_node,
                                          self.main_menu_focus)

    madgui.add_button_range(self.main_menu_page, false, 1,
        { button_node = self.main_menu_play,
          callback = function() madgui.activate(self.level_menu_page) end},
        { button_node = self.main_menu_settings,
          callback = function() madgui.activate(self.settings_page) end},
        { button_node = self.main_menu_quit,
          callback = function()
              save_settings(self)
              msg.post("@system:", "exit", {code = 0})
          end})

    self.level_menu_page = madgui.add_page(self.gui_manager,
                                           self.level_menu_node,
                                           self.level_menu_focus)

    madgui.add_on_escape_callback(self.level_menu_page,
                                  function()
                                      madgui.activate(self.main_menu_page)
                                  end)
    madgui.add_button_range(self.level_menu_page, false, 1,
        { button_node = self.level_menu_lvl1,
          callback = function() start_level(self, 1) end},
        { button_node = self.level_menu_lvl2,
          callback = function() start_level(self, 2) end},
        { button_node = self.level_menu_lvl3,
          callback = function() start_level(self, 3) end},
        { button_node = self.level_menu_back,
          callback = function() madgui.activate(self.main_menu_page) end})

    self.focus_boxed = {
        [self.controls_selection]    = self.std_input,
        [self.difficulty_selection ] = self.easy_input
    }

    gui.set_color(self.difficulty_selection, const.color_green)

    load_settings(self)

    madgui.activate(self.main_menu_page)
end

function on_input(self, action_id, action)
    madgui.handle_manager_input(self.gui_manager, action_id, action)
end

function on_message(self, message_id, message, sender)
    if message_id == hash("hide_menu") then
        madgui.hide_all_pages(self.gui_manager)
    end
    if message_id == hash("show_menu") then
        self.gui_manager.cursor_pos.x = message.cursor_x
        self.gui_manager.cursor_pos.y = message.cursor_y
        gui.set_position(self.cursor_node, self.gui_manager.cursor_pos)
        madgui.activate(self.main_menu_page)
    end
end