import yaml
import wx
import logging


class Config(object):
    """
    Provides access to application configuration parameters stored in config.yaml.
    """

    config_filepath = None
    __config = None
    __instance = None

    def __new__(cls):
        """
        Singleton. Get instance of this class. Create if not already created.
        :return:
        """
        if cls.__instance is None:
            cls.__instance = super(Config, cls).__new__(cls)
        return cls.__instance

    def load(self, path):
        """
        Loads the applications config file
        :param path: Path to config file
        :return:
        """
        with open(path, 'r') as yamlfile:
            self.__config = yaml.safe_load(yamlfile)

        # Store path so that we can save later
        self.config_filepath = path

    def save(self):
        """
        Saves config file
        :return:
        """

        with open(self.config_filepath, 'w') as file:
            file.write("---\n")
            yaml.dump(self.__config, file, sort_keys=False)
            file.write("...")

    def get(self, path):
        """
        Gets a config property value.
        :param path: path to property. Path separated by .
        :return: property value
        """

        elements = path.split('.')
        last = None

        for element in elements:
            if last is None:
                last = self.__config[element]
            else:
                last = last[element]

        return last

    def get_root_nodes(self):
        """
        Returns all root notes as a list
        :return: dict of root notes of YAML config file
        """
        nodes = []
        for key in self.__config:
            nodes.append(key)

        return nodes

    def set(self, path, value):
        """
        Sets a config property value
        :param path: path to property. Path separated by .
        :param value: Value to set property to
        :return:
        """
        obj = self.__config
        key_list = path.split(".")

        for k in key_list[:-1]:
            obj = obj[k]

        obj[key_list[-1]] = value


class SettingsDialog(wx.Dialog):
    """
    A dialog box for changing settings. A tab for each root node, with a tree view on left for every branch and a text
    box for every value.
    """

    # Store any settings that have changed
    changed_settings = {}

    def __init__(self, *args, **kwargs):
        # Super Constructor
        wx.Dialog.__init__(self, *args, **kwargs)
        self.SetTitle("Settings")

        # Create logger and get config
        self.__log = logging.getLogger(__name__)
        self.__settings = Config()

        # Dict of changes. Will commit only on ok
        self.__changes = {}

        # We want 2 vertical sections, the tabbed notebook and the buttons. The buttons sizer will have 2 horizontal
        # sections, one for each button.
        main_sizer = wx.BoxSizer(wx.VERTICAL)  # Notebook panel
        button_sizer = wx.BoxSizer(wx.HORIZONTAL)  # Button sizer

        # Notebook
        self.__notebook = wx.Notebook(self, wx.ID_ANY)  # The notebook

        # A tab for each root node in config. We will store the tabs components in lists which can be accessed by the
        # index returned from notebook.GetSelectedItem()
        root_nodes = self.__settings.get_root_nodes()
        self.__tabs = []
        for node in root_nodes:
            # Create new tab
            self.__tabs.append(SettingsTab(self, self.__notebook, node))

            # Add tab to notebook
            self.__notebook.AddPage(self.__tabs[-1], node)

        # Buttons
        button_ok = wx.Button(self, label="Update")
        button_cancel = wx.Button(self, label="Cancel")
        button_sizer.Add(button_ok, 0, wx.ALL, 1)
        button_sizer.Add(button_cancel, 0, wx.ALL, 1)

        # Add notebook and button sizer to main sizer and set main sizer for window
        main_sizer.Add(self.__notebook, 1, wx.ALL | wx.EXPAND, 5)
        main_sizer.Add(button_sizer)
        self.SetSizer(main_sizer)

        # Bind buttons &  notebook page select.
        button_ok.Bind(wx.EVT_BUTTON, self.__on_ok)
        button_cancel.Bind(wx.EVT_BUTTON, self.__on_cancel)
        self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.__on_page_select)

        # Call on_page_select to select the first page
        self.__on_page_select(event=None)

    def __on_page_select(self, event):
        # Call the tabs select method to populate
        index = self.__notebook.GetSelection()
        self.__tabs[index].select()

    def __on_cancel(self, event):
        # Clear changed settings and close
        self.changed_settings = {}
        self.EndModal(wx.ID_CANCEL)
        self.Destroy()

    def __on_ok(self, event):
        # Update settings and save
        delkeys = []
        for setting in self.changed_settings:
            # Get the current and new setting
            orig_value = self.__settings.get(setting)
            new_value = self.changed_settings[setting]

            # If they are the same, discard from changes. We will use a list of items to delete (delkeys) as we cant
            # delete whilst iterating. If they are different, update settings.
            if orig_value == new_value:
                delkeys.append(setting)
            else:
                # We need to retain data type. New values will all be string as they were retrieved from textctl.
                # Get the data type of the original and cast new to it.
                new_value = type(orig_value)(new_value)
                self.__settings.set(setting, new_value)

        # Now delete the items that were the same from changed_settings. changed_settings may be used by settings
        # dialog caller.
        for key in delkeys:
            del(self.changed_settings[key])

        # Save the settings and close dialog
        self.__settings.save()
        self.EndModal(wx.ID_OK)
        self.Destroy()


class SettingsTab(wx.Panel):
    """
    A notebook tab containing the settings tree and values for a settings root node.
    """

    # Root node for this tab
    __root_node_name = None

    # Parent frame. Set during constructor
    __parent_frame = None

    # Each tab has: a tree view; a values panel; and a list of value text boxes bound to a change
    # event.
    __tree = None
    __tab_sizer = None

    # Currently displayed value panel. Will be switched when tree menu items are selected.
    __current_value_panel = None

    def __init__(self, parent_frame, notebook, root_node):
        """
        Creates a tab for the settings notebook.

        :param parent_frame: The frame containing the notebook.
        :param notebook. The notebook that this tab should be part of.
        :param root_node. The root node name for the settings
        """
        # Super Constructor
        wx.Panel.__init__(self, parent=notebook)

        # Store the parent frame and get the settings for this tab.
        self.__parent_frame = parent_frame
        settings = Config().get(root_node)

        # Store the root node for this tab
        self.__root_node_name = root_node

        # Create logger
        self.__log = logging.getLogger(__name__)

        # Build the tab and set it's sizer.
        self.__tab_sizer = wx.BoxSizer(wx.HORIZONTAL)
        self.SetSizer(self.__tab_sizer)

        # Create tree control and build
        self.__tree = wx.TreeCtrl(self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize)
        self.__tree = self.__build_tree(self.__tree, None, settings)

        # expand tree and add it to the sizer
        self.__tree.Expand(self.__tree.GetRootItem())
        self.__tab_sizer.Add(self.__tree, 1, wx.ALL | wx.EXPAND, 1)

        # Bind tree selection changed
        self.__tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.__on_tree_select)

    def select(self):
        """
        To be called when this tab is selected. Populate value sizer for the selected item, If no item is selected,
        populate for root.
        :return:
        """
        selected_item = self.__tree.GetSelection()
        if selected_item.ID is None:
            root_node = self.__tree.GetRootItem()
            setting_path = self.__tree.GetItemData(root_node)
        else:
            setting_path = self.__tree.GetItemData(selected_item)

        # Set the panel
        self.__switch_value_panel(setting_path)

    def __build_tree(self, tree, node, settings):
        """
        Recursive function to build the tree and value panels from the node using the settings
        :param tree: The tree to build. Can be None if node is None (root)
        :param node: The tree view node. If None, then build from root.
        :param settings: The settings dict for the node.
        :return: The built tree
        """

        # Build root node if node is not specified
        if node is None:
            setting = self.__root_node_name
            node = self.__tree.AddRoot(setting)
            tree.SetItemData(node, setting)

        for setting in settings:
            # Get settings path

            settings_path = f"{tree.GetItemData(node)}.{setting}"

            # Get value. If dict, add the node and recursively call this function again.
            value = settings[setting]
            if type(value) is dict:
                # Add the node and set its settings path
                node_id = tree.AppendItem(node, setting)
                tree.SetItemData(node_id, settings_path)

                # Recurse
                tree = self.__build_tree(tree, node_id, value)

        return tree

    def __on_tree_select(self, event):
        """
        Called when an item in the tree is selected. Displays the correct settings panel
        :param event:
        :return:
        """
        # Get Selected item and check that it is a tree item
        tree_item = event.GetItem()
        if not tree_item.IsOk():
            return

        # Get the setting path from item data
        setting_path = self.__tree.GetItemData(tree_item)

        # Switch the panel
        self.__switch_value_panel(setting_path)

    def __switch_value_panel(self, setting_path):
        """
        Switched the value panel to the correct one for the settings path
        :param setting_path:
        :return:
        """
        # Get current panel and delete.
        if self.__current_value_panel is not None:
            self.__current_value_panel.Destroy()

        # Create the new value panel and add to sizer.
        self.__current_value_panel = SettingsValuePanel(self.__parent_frame, self, setting_path)
        self.__tab_sizer.Add(self.__current_value_panel, 1, wx.ALL | wx.EXPAND, 1)

        # Redraw
        self.__tab_sizer.Layout()


class SettingsValuePanel(wx.Panel):
    """
    A panel containing text boxes for editing values for a settings node
    """

    __value_sizer = None
    __value_boxes = []

    def __init__(self, parent_frame, settings_tab, node):
        """
        Creates a tab for the settings notebook.

        :param parent_frame: The frame containing the notebook.
        :param settings_tab. The settings_tab on which this panel should be displayed.
        :param node. The node name for the settings who's values will be presented
        """
        # Super Constructor
        wx.Panel.__init__(self, parent=settings_tab)

        # Create logger
        self.__log = logging.getLogger(__name__)

        # Store the parent frame and get the settings for this node.
        self.__parent_frame = parent_frame
        settings = Config().get(node)

        leaf_settings = {}
        for setting in settings:
            if type(settings[setting]) is not dict:
                leaf_settings[setting] = settings[setting]

        # Add the value sizer for settings values.
        self.__value_sizer = wx.FlexGridSizer(rows=len(leaf_settings), cols=2, vgap=2, hgap=2)

        # Add the sizer to the panel
        self.SetSizer(self.__value_sizer)

        # Display every value
        for setting in leaf_settings:
            # Setting path
            setting_path = f"{node}.{setting}"

            # Value. Make sure that we display changed value if already changed
            if setting_path in self.__parent_frame.changed_settings:
                value = self.__parent_frame.changed_settings[setting_path]
            else:
                value = leaf_settings[setting]

            # Add a label and value text box
            label = wx.StaticText(self, wx.ID_ANY, setting, style=wx.ALIGN_LEFT)
            self.__value_boxes.append(wx.TextCtrl(self, wx.ID_ANY, f"{value}", style=wx.ALIGN_LEFT))
            self.__value_sizer.AddMany([(label, 0, wx.EXPAND), (self.__value_boxes[-1], 0, wx.EXPAND)])

            # Bind to text change. We need to generate a handler as this will have a parameter.
            self.__value_boxes[-1].Bind(wx.EVT_TEXT, self.__get_on_change_evt_handler(setting_path=setting_path))

        # Layout the value sizer
        self.__value_sizer.Layout()

    def __get_on_change_evt_handler(self, setting_path):
        """
        Returns a new event handler with a parameter of the settings path
        :param setting_path:
        :return:
        """

        def on_value_changed(event):
            self.__parent_frame.changed_settings[setting_path] = event.String
            self.__log.debug(f"Value changed for {setting_path}.")

        return on_value_changed