# (C) Copyright 2005-2023 Enthought, Inc., Austin, TX
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in LICENSE.txt and may be redistributed only under
# the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!


""" The wx specific implementation of the tool bar manager.
"""


import wx

from traits.api import Bool, Instance, Str, Tuple, provides

from pyface.wx.aui import aui as AUI
from pyface.image_cache import ImageCache
from pyface.action.action_manager import ActionManager
from pyface.action.i_tool_bar_manager import IToolBarManager
from pyface.ui_traits import Orientation


@provides(IToolBarManager)
class ToolBarManager(ActionManager):
    """ A tool bar manager realizes itself in errr, a tool bar control. """

    # 'ToolBarManager' interface -------------------------------------------

    # Is the tool bar enabled?
    enabled = Bool(True)

    # Is the tool bar visible?
    visible = Bool(True)

    # The size of tool images (width, height).
    image_size = Tuple((16, 16))

    # The toolbar name (used to distinguish multiple toolbars).
    name = Str("ToolBar")

    # The orientation of the toolbar.
    orientation = Orientation("horizontal")

    # Should we display the name of each tool bar tool under its image?
    show_tool_names = Bool(True)

    # Should we display the horizontal divider?
    show_divider = Bool(False)

    # Private interface ----------------------------------------------------

    # Cache of tool images (scaled to the appropriate size).
    _image_cache = Instance(ImageCache)

    # ------------------------------------------------------------------------
    # 'object' interface.
    # ------------------------------------------------------------------------

    def __init__(self, *args, **traits):
        """ Creates a new tool bar manager. """

        # Base class contructor.
        super().__init__(*args, **traits)

        # An image cache to make sure that we only load each image used in the
        # tool bar exactly once.
        self._image_cache = ImageCache(self.image_size[0], self.image_size[1])

        return

    # ------------------------------------------------------------------------
    # 'ToolBarManager' interface.
    # ------------------------------------------------------------------------

    def create_tool_bar(self, parent, controller=None, aui=False):
        """ Creates a tool bar. """

        # If a controller is required it can either be set as a trait on the
        # tool bar manager (the trait is part of the 'ActionManager' API), or
        # passed in here (if one is passed in here it takes precedence over the
        # trait).
        if controller is None:
            controller = self.controller

        # Determine the wx style for the tool bar based on any optional
        # settings.
        style = wx.NO_BORDER | wx.CLIP_CHILDREN
        if aui:
            aui_style = AUI.AUI_TB_PLAIN_BACKGROUND
            if self.show_tool_names:
                aui_style |= AUI.AUI_TB_TEXT
            if self.orientation != "horizontal":
                aui_style |= AUI.AUI_TB_VERTICAL
            if not self.show_divider:
                style |= wx.TB_NODIVIDER
            tool_bar = _AuiToolBar(
                self, parent, -1, style=style, agwStyle=aui_style
            )
        else:
            style |= wx.TB_FLAT
            if self.show_tool_names:
                style |= wx.TB_TEXT
            if self.orientation == "horizontal":
                style |= wx.TB_HORIZONTAL
            else:
                style |= wx.TB_VERTICAL
            if not self.show_divider:
                style |= wx.TB_NODIVIDER
            tool_bar = _ToolBar(self, parent, -1, style=style)

        # fixme: Setting the tool bitmap size seems to be the only way to
        # change the height of the toolbar in wx.
        tool_bar.SetToolBitmapSize(self.image_size)

        # Add all of items in the manager's groups to the tool bar.
        self._wx_add_tools(parent, tool_bar, controller)

        # Make the tools appear in the tool bar (without this you will see
        # nothing!).
        tool_bar.Realize()

        # fixme: Without the following hack,  only the first item in a radio
        # group can be selected when the tool bar is first realised 8^()
        self._wx_set_initial_tool_state(tool_bar)

        return tool_bar

    # ------------------------------------------------------------------------
    # Private interface.
    # ------------------------------------------------------------------------

    def _wx_add_tools(self, parent, tool_bar, controller):
        """ Adds tools for all items in the list of groups. """

        previous_non_empty_group = None
        for group in self.groups:
            if len(group.items) > 0:
                # Is a separator required?
                if previous_non_empty_group is not None and group.separator:
                    tool_bar.AddSeparator()

                previous_non_empty_group = group

                # Create a tool bar tool for each item in the group.
                for item in group.items:
                    item.add_to_toolbar(
                        parent,
                        tool_bar,
                        self._image_cache,
                        controller,
                        self.show_tool_names,
                    )

    def _wx_set_initial_tool_state(self, tool_bar):
        """ Workaround for the wxPython tool bar bug.

        Without this,  only the first item in a radio group can be selected
         when the tool bar is first realised 8^()

        """

        for group in self.groups:
            checked = False
            for item in group.items:
                # If the group is a radio group,  set the initial checked state
                # of every tool in it.
                if item.action.style == "radio":
                    if item.control_id is not None:
                        # Only set checked state if control has been created.
                        # Using extra_actions of tasks, it appears that this
                        # may be called multiple times.
                        tool_bar.ToggleTool(
                            item.control_id, item.action.checked
                        )
                        checked = checked or item.action.checked

                # Every item in a radio group MUST be 'radio' style, so we
                # can just skip to the next group.
                else:
                    break

            # We get here if the group is a radio group.
            else:
                # If none of the actions in the group is specified as 'checked'
                # we will check the first one.
                if not checked and len(group.items) > 0:
                    group.items[0].action.checked = True


class _ToolBar(wx.ToolBar):
    """ The toolkit-specific tool bar implementation. """

    # ------------------------------------------------------------------------
    # 'object' interface.
    # ------------------------------------------------------------------------

    def __init__(self, tool_bar_manager, parent, id, style):
        """ Constructor. """

        wx.ToolBar.__init__(self, parent, -1, style=style)

        # Listen for changes to the tool bar manager's enablement and
        # visibility.
        self.tool_bar_manager = tool_bar_manager

        self.tool_bar_manager.observe(
            self._on_tool_bar_manager_enabled_changed, "enabled"
        )

        self.tool_bar_manager.observe(
            self._on_tool_bar_manager_visible_changed, "visible"
        )

        return

    # ------------------------------------------------------------------------
    # Trait change handlers.
    # ------------------------------------------------------------------------

    def _on_tool_bar_manager_enabled_changed(self, event):
        """ Dynamic trait change handler. """

        event.object.window._wx_enable_tool_bar(self, event.new)

    def _on_tool_bar_manager_visible_changed(self, event):
        """ Dynamic trait change handler. """

        event.object.window._wx_show_tool_bar(self, event.new)


class _AuiToolBar(AUI.AuiToolBar):
    """ The toolkit-specific tool bar implementation for AUI windows. """

    # ------------------------------------------------------------------------
    # 'object' interface.
    # ------------------------------------------------------------------------

    def __init__(self, tool_bar_manager, parent, id, style, agwStyle):
        """ Constructor. """

        super().__init__(parent, -1, style=style, agwStyle=agwStyle)

        # Listen for changes to the tool bar manager's enablement and
        # visibility.
        self.tool_bar_manager = tool_bar_manager

        self.tool_bar_manager.observe(
            self._on_tool_bar_manager_enabled_changed, "enabled"
        )

        self.tool_bar_manager.observe(
            self._on_tool_bar_manager_visible_changed, "visible"
        )

        # we need to defer hiding tools until first time Realize is called so
        # we can get the correct order of the toolbar for reinsertion at the
        # correct position
        self.initially_hidden_tool_ids = []

        # map of tool ids to a tuple: position in full toolbar and the
        # ToolBarTool itself.  Can't keep a weak reference here because once
        # removed from the toolbar the item would be garbage collected.
        self.tool_map = {}

    def Realize(self):
        if len(self.tool_map) == 0:
            for pos in range(self.GetToolsCount()):
                tool = self.GetToolByPos(pos)
                self.tool_map[tool.GetId()] = (pos, tool)
        AUI.AuiToolBar.Realize(self)
        if len(self.initially_hidden_tool_ids) > 0:
            for tool_id in self.initially_hidden_tool_ids:
                self.RemoveTool(tool_id)
            self.initially_hidden_tool_ids = []
        self.ShowTool = self.ShowToolPostRealize

    def ShowTool(self, tool_id, state):
        """Used before realization to flag which need to be initially hidden
        """
        if not state:
            self.initially_hidden_tool_ids.append(tool_id)

    def ShowToolPostRealize(self, tool_id, state):
        """Normal ShowTool method, activated after first call to Realize
        """
        tool = self.FindById(tool_id)
        if state and tool is None:
            self.InsertToolInOrder(tool_id)
            self.EnableTool(tool_id, True)
            self.Realize()
            # Update the toolbar in the AUI manager to force toolbar resize
            try:
                wx.CallAfter(
                    self.tool_bar_manager.controller.task.window._aui_manager.Update
                )
            except:
                pass
        elif not state and tool is not None:
            self.RemoveTool(tool_id)
            # Update the toolbar in the AUI manager to force toolbar resize
            try:
                wx.CallAfter(
                    self.tool_bar_manager.controller.task.window._aui_manager.Update
                )
            except:
                pass

    def InsertToolInOrder(self, tool_id):
        orig_pos, tool = self.tool_map[tool_id]
        pos = -1
        for pos in range(self.GetToolsCount()):
            existing_orig_pos, _ = self.tool_map[tool_id]
            if existing_orig_pos > orig_pos:
                break
        self.InsertToolItem(pos + 1, tool)

    ## Additional convenience functions for the normal AGW AUI toolbar

    def AddLabelTool(
        self,
        id,
        label,
        bitmap,
        bmpDisabled,
        kind,
        shortHelp,
        longHelp,
        clientData,
    ):
        "The full AddTool() function."
        return self.AddTool(
            id,
            label,
            bitmap,
            bmpDisabled,
            kind,
            shortHelp,
            longHelp,
            clientData,
            None,
        )

    def InsertToolItem(self, pos, tool):
        self._items[pos:pos] = [tool]
        return tool

    def DeleteTool(self, tool_id):
        """
        Removes the specified tool from the toolbar and deletes it.

        :param integer `tool_id`: the :class:`AuiToolBarItem` identifier.
        :returns: ``True`` if the tool was deleted, ``False`` otherwise.
        :note: Note that it is unnecessary to call :meth:`Realize` for the
            change to take place, it will happen immediately.
        """

        tool = self.RemoveTool(tool_id)
        if tool is not None:
            tool.Destroy()
            return True

        return False

    def RemoveTool(self, tool_id):
        """
        Removes the specified tool from the toolbar but doesn't delete it.

        :param integer `tool_id`: the :class:`AuiToolBarItem` identifier.
        :returns: ``True`` if the tool was deleted, ``False`` otherwise.
        :note: Note that it is unnecessary to call :meth:`Realize` for the
            change to take place, it will happen immediately.
        """

        idx = self.GetToolIndex(tool_id)

        if idx >= 0 and idx < len(self._items):
            self._items.pop(idx)
            self.Realize()
            return True

        return False

    FindById = AUI.AuiToolBar.FindTool

    GetToolState = AUI.AuiToolBar.GetToolToggled

    GetToolsCount = AUI.AuiToolBar.GetToolCount

    def GetToolByPos(self, pos):
        return self._items[pos]

    def OnSize(self, event):
        # Quickly short-circuit if the toolbar isn't realized
        if not hasattr(self, "_absolute_min_size"):
            return

        AUI.AuiToolBar.OnSize(self, event)

    # ------------------------------------------------------------------------
    # Trait change handlers.
    # ------------------------------------------------------------------------

    def _on_tool_bar_manager_enabled_changed(self, event):
        """ Dynamic trait change handler. """

        try:
            event.object.controller.task.window._wx_enable_tool_bar(
                self, event.new
            )
        except:

            pass

    def _on_tool_bar_manager_visible_changed(self, event):
        """ Dynamic trait change handler. """

        try:
            event.object.controller.task.window._wx_show_tool_bar(
                self, event.new
            )
        except:

            pass
        return