# (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!
# (C) Copyright 2008 Riverbank Computing Limited
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD license.
# However, when used with the GPL version of PyQt the additional terms described in the PyQt GPL exception also apply


import logging


from pyface.qt import QtCore, QtGui


from traits.api import Instance, observe


from pyface.message_dialog import error
from pyface.workbench.i_workbench_window_layout import MWorkbenchWindowLayout
from .split_tab_widget import SplitTabWidget


# Logging.
logger = logging.getLogger(__name__)


# For mapping positions relative to the editor area.
_EDIT_AREA_MAP = {
    "left": QtCore.Qt.DockWidgetArea.LeftDockWidgetArea,
    "right": QtCore.Qt.DockWidgetArea.RightDockWidgetArea,
    "top": QtCore.Qt.DockWidgetArea.TopDockWidgetArea,
    "bottom": QtCore.Qt.DockWidgetArea.BottomDockWidgetArea,
}

# For mapping positions relative to another view.
_VIEW_AREA_MAP = {
    "left": (QtCore.Qt.Orientation.Horizontal, True),
    "right": (QtCore.Qt.Orientation.Horizontal, False),
    "top": (QtCore.Qt.Orientation.Vertical, True),
    "bottom": (QtCore.Qt.Orientation.Vertical, False),
}


class WorkbenchWindowLayout(MWorkbenchWindowLayout):
    """ The Qt4 implementation of the workbench window layout interface.

    See the 'IWorkbenchWindowLayout' interface for the API documentation.

    """

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

    # The widget that provides the editor area.  We keep (and use) this
    # separate reference because we can't always assume that it has been set to
    # be the main window's central widget.
    _qt4_editor_area = Instance(SplitTabWidget)

    # ------------------------------------------------------------------------
    # 'IWorkbenchWindowLayout' interface.
    # ------------------------------------------------------------------------

    def activate_editor(self, editor):
        if editor.control is not None:
            editor.control.show()
            self._qt4_editor_area.setCurrentWidget(editor.control)
            editor.set_focus()

        return editor

    def activate_view(self, view):
        # FIXME v3: This probably doesn't work as expected.
        view.control.raise_()
        view.set_focus()

        return view

    def add_editor(self, editor, title):
        if editor is None:
            return None

        try:
            self._qt4_editor_area.addTab(
                self._qt4_get_editor_control(editor), title
            )

            if editor._loading_on_open:
                self._qt4_editor_tab_spinner(editor, "", True)
        except Exception:
            logger.exception("error creating editor control [%s]", editor.id)

        return editor

    def add_view(self, view, position=None, relative_to=None, size=(-1, -1)):
        if view is None:
            return None

        try:
            self._qt4_add_view(view, position, relative_to, size)
            view.visible = True
        except Exception:
            logger.exception("error creating view control [%s]", view.id)

            # Even though we caught the exception, it sometimes happens that
            # the view's control has been created as a child of the application
            # window (or maybe even the dock control).  We should destroy the
            # control to avoid bad UI effects.
            view.destroy_control()

            # Additionally, display an error message to the user.
            error(
                self.window.control,
                "Unable to add view [%s]" % view.id,
                "Workbench Plugin Error",
            )

        return view

    def close_editor(self, editor):
        if editor.control is not None:
            editor.control.close()

        return editor

    def close_view(self, view):
        self.hide_view(view)

        return view

    def close(self):
        # Don't fire signals for editors that have destroyed their controls.
        self._qt4_editor_area.editor_has_focus.disconnect(
            self._qt4_editor_focus
        )

        self._qt4_editor_area.clear()

        # Delete all dock widgets.
        for v in self.window.views:
            if self.contains_view(v):
                self._qt4_delete_view_dock_widget(v)

    def create_initial_layout(self, parent):
        self._qt4_editor_area = editor_area = SplitTabWidget(parent)

        editor_area.editor_has_focus.connect(self._qt4_editor_focus)

        # We are interested in focus changes but we get them from the editor
        # area rather than qApp to allow the editor area to restrict them when
        # needed.
        editor_area.focus_changed.connect(self._qt4_view_focus_changed)

        editor_area.tabTextChanged.connect(self._qt4_editor_title_changed)
        editor_area.new_window_request.connect(self._qt4_new_window_request)
        editor_area.tab_close_request.connect(self._qt4_tab_close_request)
        editor_area.tab_window_changed.connect(self._qt4_tab_window_changed)

        return editor_area

    def contains_view(self, view):
        return hasattr(view, "_qt4_dock")

    def hide_editor_area(self):
        self._qt4_editor_area.hide()

    def hide_view(self, view):
        view._qt4_dock.hide()
        view.visible = False

        return view

    def refresh(self):
        # Nothing to do.
        pass

    def reset_editors(self):
        self._qt4_editor_area.setCurrentIndex(0)

    def reset_views(self):
        # Qt doesn't provide information about the order of dock widgets in a
        # dock area.
        pass

    def show_editor_area(self):
        self._qt4_editor_area.show()

    def show_view(self, view):
        view._qt4_dock.show()
        view.visible = True

    # Methods for saving and restoring the layout -------------------------#

    def get_view_memento(self):
        # Get the IDs of the views in the main window.  This information is
        # also in the QMainWindow state, but that is opaque.
        view_ids = [v.id for v in self.window.views if self.contains_view(v)]

        # Everything else is provided by QMainWindow.
        state = self.window.control.saveState().data()
        return (0, (view_ids, state))

    def set_view_memento(self, memento):
        version, mdata = memento

        # There has only ever been version 0 so far so check with an assert.
        assert version == 0

        # Now we know the structure of the memento we can "parse" it.
        view_ids, state = mdata

        # Get a list of all views that have dock widgets and mark them.
        dock_views = [v for v in self.window.views if self.contains_view(v)]

        for v in dock_views:
            v._qt4_gone = True

        # Create a dock window for all views that had one last time.
        for v in self.window.views:
            # Make sure this is in a known state.
            v.visible = False

            for vid in view_ids:
                if vid == v.id:
                    # Create the dock widget if needed and make sure that it is
                    # invisible so that it matches the state of the visible
                    # trait.  Things will all come right when the main window
                    # state is restored below.
                    self._qt4_create_view_dock_widget(v).setVisible(False)

                    if v in dock_views:
                        delattr(v, "_qt4_gone")

                    break

        # Remove any remain unused dock widgets.
        for v in dock_views:
            try:
                delattr(v, "_qt4_gone")
            except AttributeError:
                pass
            else:
                self._qt4_delete_view_dock_widget(v)

        # Restore the state.  This will update the view's visible trait through
        # the dock window's toggle action.
        self.window.control.restoreState(state)

    def get_editor_memento(self):
        # Get the layout of the editors.
        editor_layout = self._qt4_editor_area.saveState()

        # Get a memento for each editor that describes its contents.
        editor_references = self._get_editor_references()

        return (0, (editor_layout, editor_references))

    def set_editor_memento(self, memento):
        version, mdata = memento

        # There has only ever been version 0 so far so check with an assert.
        assert version == 0

        # Now we know the structure of the memento we can "parse" it.
        editor_layout, editor_references = mdata

        def resolve_id(id):
            # Get the memento for the editor contents (if any).
            editor_memento = editor_references.get(id)

            if editor_memento is None:
                return None

            # Create the restored editor.
            editor = self.window.editor_manager.set_editor_memento(
                editor_memento
            )
            if editor is None:
                return None

            # Save the editor.
            self.window.editors.append(editor)

            # Create the control if needed and return it.
            return self._qt4_get_editor_control(editor)

        self._qt4_editor_area.restoreState(editor_layout, resolve_id)

    def get_toolkit_memento(self):
        return (0, {"geometry": self.window.control.saveGeometry()})

    def set_toolkit_memento(self, memento):
        if hasattr(memento, "toolkit_data"):
            data = memento.toolkit_data
            if isinstance(data, tuple) and len(data) == 2:
                version, datadict = data
                if version == 0:
                    geometry = datadict.pop("geometry", None)
                    if geometry is not None:
                        self.window.control.restoreGeometry(geometry)

    def is_editor_area_visible(self):
        return self._qt4_editor_area.isVisible()

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

    def _qt4_editor_focus(self, new):
        """ Handle an editor getting the focus. """

        for editor in self.window.editors:
            control = editor.control
            editor.has_focus = control is new or (
                control is not None and new in control.children()
            )

    def _qt4_editor_title_changed(self, control, title):
        """ Handle the title being changed """
        for editor in self.window.editors:
            if editor.control == control:
                editor.name = str(title)

    def _qt4_editor_tab_spinner(self, event):
        editor = event.object

        # Do we need to do this verification?
        tw, tidx = self._qt4_editor_area._tab_widget(editor.control)

        if event.new:
            tw.show_button(tidx)
        else:
            tw.hide_button(tidx)

        if not event.new and not editor == self.window.active_editor:
            self._qt4_editor_area.setTabTextColor(
                editor.control, QtCore.Qt.GlobalColor.red
            )

    @observe("window:active_editor")
    def _qt4_active_editor_changed(self, event):
        """ Handle change of active editor """
        # Reset tab title to foreground color
        editor = event.new
        if editor is not None:
            self._qt4_editor_area.setTabTextColor(editor.control)

    def _qt4_view_focus_changed(self, old, new):
        """ Handle the change of focus for a view. """

        focus_part = None

        if new is not None:
            # Handle focus changes to views.
            for view in self.window.views:
                if view.control is not None and view.control.isAncestorOf(new):
                    view.has_focus = True
                    focus_part = view
                    break

        if old is not None:
            # Handle focus changes from views.
            for view in self.window.views:
                if (
                    view is not focus_part
                    and view.control is not None
                    and view.control.isAncestorOf(old)
                ):
                    view.has_focus = False
                    break

    def _qt4_new_window_request(self, pos, control):
        """ Handle a tab tear-out request from the splitter widget. """

        editor = self._qt4_remove_editor_with_control(control)
        kind = self.window.editor_manager.get_editor_kind(editor)

        window = self.window.workbench.create_window()
        window.open()
        window.add_editor(editor)
        window.editor_manager.add_editor(editor, kind)
        window.position = (pos.x(), pos.y())
        window.size = self.window.size
        window.activate_editor(editor)
        editor.window = window

    def _qt4_tab_close_request(self, control):
        """ Handle a tabCloseRequest from the splitter widget. """

        for editor in self.window.editors:
            if editor.control == control:
                editor.close()
                break

    def _qt4_tab_window_changed(self, control):
        """ Handle a tab drag to a different WorkbenchWindow. """

        editor = self._qt4_remove_editor_with_control(control)
        kind = self.window.editor_manager.get_editor_kind(editor)

        while not control.isWindow():
            control = control.parent()
        for window in self.window.workbench.windows:
            if window.control == control:
                window.editors.append(editor)
                window.editor_manager.add_editor(editor, kind)
                window.layout._qt4_get_editor_control(editor)
                window.activate_editor(editor)
                editor.window = window
                break

    def _qt4_remove_editor_with_control(self, control):
        """ Finds the editor associated with 'control' and removes it. Returns
            the editor, or None if no editor was found.
        """
        for editor in self.window.editors:
            if editor.control == control:
                self.editor_closing = editor
                control.removeEventFilter(self._qt4_mon)
                self.editor_closed = editor

                # Make sure that focus events get fired if this editor is
                # subsequently added to another window.
                editor.has_focus = False

                return editor

    def _qt4_get_editor_control(self, editor):
        """ Create the editor control if it hasn't already been done. """

        if editor.control is None:
            self.editor_opening = editor

            # We must provide a parent (because TraitsUI checks for it when
            # deciding what sort of panel to create) but it can't be the editor
            # area (because it will be automatically added to the base
            # QSplitter).
            editor.control = editor.create_control(self.window.control)
            editor.control.setObjectName(editor.id)

            editor.observe(self._qt4_editor_tab_spinner, "_loading")

            self.editor_opened = editor

        def on_name_changed(event):
            editor = event.object
            self._qt4_editor_area.setWidgetTitle(editor.control, editor.name)

        editor.observe(on_name_changed, "name")

        self._qt4_monitor(editor.control)

        return editor.control

    def _qt4_add_view(self, view, position, relative_to, size):
        """ Add a view. """

        # If no specific position is specified then use the view's default
        # position.
        if position is None:
            position = view.position

        dw = self._qt4_create_view_dock_widget(view, size)
        mw = self.window.control

        try:
            rel_dw = relative_to._qt4_dock
        except AttributeError:
            rel_dw = None

        if rel_dw is None:
            # If we are trying to add a view with a non-existent item, then
            # just default to the left of the editor area.
            if position == "with":
                position = "left"

            # Position the view relative to the editor area.
            try:
                dwa = _EDIT_AREA_MAP[position]
            except KeyError:
                raise ValueError("unknown view position: %s" % position)

            mw.addDockWidget(dwa, dw)
        elif position == "with":
            # FIXME v3: The Qt documentation says that the second should be
            # placed above the first, but it always seems to be underneath (ie.
            # hidden) which is not what the user is expecting.
            mw.tabifyDockWidget(rel_dw, dw)
        else:
            try:
                orient, swap = _VIEW_AREA_MAP[position]
            except KeyError:
                raise ValueError("unknown view position: %s" % position)

            mw.splitDockWidget(rel_dw, dw, orient)

            # The Qt documentation implies that the layout direction can be
            # used to position the new dock widget relative to the existing one
            # but I could only get the button positions to change.  Instead we
            # move things around afterwards if required.
            if swap:
                mw.removeDockWidget(rel_dw)
                mw.splitDockWidget(dw, rel_dw, orient)
                rel_dw.show()

    def _qt4_create_view_dock_widget(self, view, size=(-1, -1)):
        """ Create a dock widget that wraps a view. """

        # See if it has already been created.
        try:
            dw = view._qt4_dock
        except AttributeError:
            dw = QtGui.QDockWidget(view.name, self.window.control)
            dw.setWidget(_ViewContainer(size, self.window.control))
            dw.setObjectName(view.id)
            dw.toggleViewAction().toggled.connect(
                self._qt4_handle_dock_visibility
            )
            dw.visibilityChanged.connect(self._qt4_handle_dock_visibility)

            # Save the dock window.
            view._qt4_dock = dw

            def on_name_changed(event):
                view._qt4_dock.setWindowTitle(view.name)

            view.observe(on_name_changed, "name")

        # Make sure the view control exists.
        if view.control is None:
            # Make sure that the view knows which window it is in.
            view.window = self.window

            try:
                view.control = view.create_control(dw.widget())
            except:
                # Tidy up if the view couldn't be created.
                delattr(view, "_qt4_dock")
                self.window.control.removeDockWidget(dw)
                dw.deleteLater()
                del dw
                raise

        dw.widget().setCentralWidget(view.control)

        return dw

    def _qt4_delete_view_dock_widget(self, view):
        """ Delete a view's dock widget. """

        dw = view._qt4_dock

        # Disassociate the view from the dock.
        if view.control is not None:
            view.control.setParent(None)

        delattr(view, "_qt4_dock")

        # Delete the dock (and the view container).
        self.window.control.removeDockWidget(dw)
        dw.deleteLater()

    def _qt4_handle_dock_visibility(self, checked):
        """ Handle the visibility of a dock window changing. """

        # Find the dock window by its toggle action.
        for v in self.window.views:
            try:
                dw = v._qt4_dock
            except AttributeError:
                continue

            sender = dw.sender()
            if sender is dw.toggleViewAction() or sender in dw.children():
                # Toggling the action or pressing the close button on
                # the view
                v.visible = checked

    def _qt4_monitor(self, control):
        """ Install an event filter for a view or editor control to keep an eye
        on certain events.
        """

        # Create the monitoring object if needed.
        try:
            mon = self._qt4_mon
        except AttributeError:
            mon = self._qt4_mon = _Monitor(self)

        control.installEventFilter(mon)


class _Monitor(QtCore.QObject):
    """ This class monitors a view or editor control. """

    def __init__(self, layout):
        QtCore.QObject.__init__(self, layout.window.control)

        self._layout = layout

    def eventFilter(self, obj, e):
        if isinstance(e, QtGui.QCloseEvent):
            for editor in self._layout.window.editors:
                if editor.control is obj:
                    self._layout.editor_closing = editor
                    editor.destroy_control()
                    self._layout.editor_closed = editor

                    break

        return False


class _ViewContainer(QtGui.QMainWindow):
    """ This class is a container for a view that allows an initial size
    (specified as a tuple) to be set.
    """

    def __init__(self, size, main_window):
        """ Initialise the object. """

        QtGui.QMainWindow.__init__(self)

        # Save the size and main window.
        self._width, self._height = size
        self._main_window = main_window

    def sizeHint(self):
        """ Reimplemented to return the initial size or the view's current
        size.
        """

        sh = self.centralWidget().sizeHint()

        if self._width > 0:
            if self._width > 1:
                w = self._width
            else:
                w = self._main_window.width() * self._width

            sh.setWidth(int(w))

        if self._height > 0:
            if self._height > 1:
                h = self._height
            else:
                h = self._main_window.height() * self._height

            sh.setHeight(int(h))

        return sh

    def showEvent(self, e):
        """ Reimplemented to use the view's current size once shown. """

        self._width = self._height = -1

        QtGui.QMainWindow.showEvent(self, e)