# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)

"""Editor Plugin"""

import logging
import sys

from qtpy.QtCore import Signal

from spyder.api.fonts import SpyderFontType
from spyder.api.plugins import SpyderDockablePlugin, Plugins
from spyder.api.plugin_registration.decorators import (
    on_plugin_available,
    on_plugin_teardown,
)
from spyder.api.translations import _
from spyder.plugins.application.api import ApplicationActions
from spyder.plugins.editor.api.actions import EditorWidgetActions
from spyder.plugins.editor.api.run import (
    SelectionContextModificator,
    ExtraAction
)
from spyder.plugins.editor.confpage import EditorConfigPage
from spyder.plugins.editor.widgets.main_widget import EditorMainWidget
from spyder.plugins.mainmenu.api import (
    ApplicationMenus,
    EditMenuSections,
    FileMenuSections,
    SearchMenuSections,
    SourceMenuSections
)
from spyder.plugins.toolbar.api import ApplicationToolbars
from spyder.plugins.run.api import RunContext


logger = logging.getLogger(__name__)


class Editor(SpyderDockablePlugin):
    """
    Editor plugin.
    """

    NAME = 'editor'
    REQUIRES = [Plugins.Application, Plugins.Console, Plugins.Preferences]
    OPTIONAL = [
        Plugins.Completions,
        Plugins.Debugger,
        Plugins.IPythonConsole,
        Plugins.MainMenu,
        Plugins.Projects,
        Plugins.OutlineExplorer,
        Plugins.Run,
        Plugins.StatusBar,
        Plugins.Switcher,
        Plugins.Toolbar
    ]
    WIDGET_CLASS = EditorMainWidget
    CONF_SECTION = NAME
    CONF_WIDGET_CLASS = EditorConfigPage
    CONF_FILE = False

    # ---- Signals
    # ------------------------------------------------------------------------
    sig_dir_opened = Signal(str)
    """
    This signal is emitted when the editor changes the current directory.

    Parameters
    ----------
    new_working_directory: str
        The new working directory path.

    Notes
    -----
    This option is available on the options menu of the editor plugin
    """

    sig_file_opened_closed_or_updated = Signal(str, str)
    """
    This signal is emitted when a file is opened, closed or updated,
    including switching among files.

    Parameters
    ----------
    filename: str
        Name of the file that was opened, closed or updated.
    language: str
        Name of the programming language of the file that was opened,
        closed or updated.
    """

    # This signal is fired for any focus change among all editor stacks
    sig_editor_focus_changed = Signal()

    sig_help_requested = Signal(dict)
    """
    This signal is emitted to request help on a given object `name`.

    Parameters
    ----------
    help_data: dict
        Dictionary required by the Help pane to render a docstring.

    Examples
    --------
    >>> help_data = {
        'obj_text': str,
        'name': str,
        'argspec': str,
        'note': str,
        'docstring': str,
        'force_refresh': bool,
        'path': str,
    }

    See Also
    --------
    :py:meth:spyder.plugins.editor.widgets.editorstack.EditorStack.send_to_help
    """

    sig_open_files_finished = Signal()
    """
    This signal is emitted when the editor finished to open files.
    """

    sig_codeeditor_created = Signal(object)
    """
    This signal is emitted when a codeeditor is created.

    Parameters
    ----------
    codeeditor: spyder.plugins.editor.widgets.codeeditor.CodeEditor
        The codeeditor.
    """

    sig_codeeditor_deleted = Signal(object)
    """
    This signal is emitted when a codeeditor is closed.

    Parameters
    ----------
    codeeditor: spyder.plugins.editor.widgets.codeeditor.CodeEditor
        The codeeditor.
    """

    sig_codeeditor_changed = Signal(object)
    """
    This signal is emitted when the current codeeditor changes.

    Parameters
    ----------
    codeeditor: spyder.plugins.editor.widgets.codeeditor.CodeEditor
        The codeeditor.
    """

    # ---- SpyderDockablePlugin API
    # ------------------------------------------------------------------------
    @staticmethod
    def get_name():
        return _('Editor')

    @staticmethod
    def get_description():
        return _(
            "Edit Python, Markdown, Cython and many other types of text files."
        )

    @classmethod
    def get_icon(cls):
        return cls.create_icon('edit')

    def on_initialize(self):
        widget = self.get_widget()

        # ---- Help related signals
        widget.sig_help_requested.connect(self.sig_help_requested)

        # ---- General signals
        widget.starting_long_process.connect(self.before_long_process)
        widget.ending_long_process.connect(self.after_long_process)
        widget.sig_dir_opened.connect(self.sig_dir_opened)
        widget.sig_file_opened_closed_or_updated.connect(
            self.sig_file_opened_closed_or_updated
        )
        widget.sig_open_files_finished.connect(self.sig_open_files_finished)

        # ---- CodeEditor related signals
        widget.sig_codeeditor_created.connect(self.sig_codeeditor_created)
        widget.sig_codeeditor_deleted.connect(self.sig_codeeditor_deleted)
        widget.sig_codeeditor_changed.connect(self.sig_codeeditor_changed)
        widget.sig_editor_focus_changed.connect(self.sig_editor_focus_changed)

        # ---- Plugin related signals
        widget.sig_switch_to_plugin_requested.connect(
            lambda: self.switch_to_plugin(force_focus=True)
        )

    @on_plugin_available(plugin=Plugins.Preferences)
    def on_preferences_available(self):
        preferences = self.get_plugin(Plugins.Preferences)
        preferences.register_plugin_preferences(self)

    @on_plugin_teardown(plugin=Plugins.Preferences)
    def on_preferences_teardown(self):
        preferences = self.get_plugin(Plugins.Preferences)
        preferences.deregister_plugin_preferences(self)

    @on_plugin_available(plugin=Plugins.StatusBar)
    def on_statusbar_available(self):
        # Add status widgets
        statusbar = self.get_plugin(Plugins.StatusBar)
        widget = self.get_widget()
        statusbar.add_status_widget(widget.readwrite_status)
        statusbar.add_status_widget(widget.eol_status)
        statusbar.add_status_widget(widget.encoding_status)
        statusbar.add_status_widget(widget.cursorpos_status)
        statusbar.add_status_widget(widget.vcs_status)

    @on_plugin_teardown(plugin=Plugins.StatusBar)
    def on_statusbar_teardown(self):
        # Remove status widgets
        statusbar = self.get_plugin(Plugins.StatusBar)
        widget = self.get_widget()
        statusbar.remove_status_widget(widget.readwrite_status.ID)
        statusbar.remove_status_widget(widget.eol_status.ID)
        statusbar.remove_status_widget(widget.encoding_status.ID)
        statusbar.remove_status_widget(widget.cursorpos_status.ID)
        statusbar.remove_status_widget(widget.vcs_status.ID)

    @on_plugin_available(plugin=Plugins.Run)
    def on_run_available(self):
        widget = self.get_widget()
        run = self.get_plugin(Plugins.Run)

        widget.sig_editor_focus_changed_uuid.connect(
            run.switch_focused_run_configuration
        )
        widget.sig_register_run_configuration_provider_requested.connect(
            lambda supported_extensions:
                run.register_run_configuration_provider(
                    self.NAME, supported_extensions
                )
        )
        widget.sig_deregister_run_configuration_provider_requested.connect(
            lambda unsupported_extensions:
                run.deregister_run_configuration_provider(
                    self.NAME, unsupported_extensions
                )
        )

        # This is necessary to register run configs that were added before Run
        # is available
        for extension in widget.supported_run_extensions:
            run.register_run_configuration_provider(self.NAME, [extension])

        # Buttons creation
        run.create_run_button(
            RunContext.Cell,
            _("Run cell"),
            icon=self.create_icon('run_cell'),
            tip=_("Run cell"),
            shortcut_context=self.NAME,
            register_shortcut=True,
            add_to_toolbar=True,
            add_to_menu=True
        )
        run.create_run_button(
            RunContext.Cell,
            _("Run cell and advance"),
            icon=self.create_icon('run_cell_advance'),
            tip=_("Run cell and advance"),
            shortcut_context=self.NAME,
            register_shortcut=True,
            add_to_toolbar=True,
            add_to_menu=True,
            extra_action_name=ExtraAction.Advance
        )
        run.create_run_button(
            RunContext.Cell,
            _("Re-run last cell"),
            tip=_("Re run last cell "),
            shortcut_context=self.NAME,
            register_shortcut=True,
            add_to_menu=True,
            re_run=True
        )
        run.create_run_button(
            RunContext.Selection,
            _("Run &current line/selection"),
            icon=self.create_icon('run_selection'),
            tip=_("Run current line or selection"),
            shortcut_context=self.NAME,
            register_shortcut=True,
            add_to_toolbar=True,
            add_to_menu=True,
            extra_action_name=ExtraAction.Advance,
        )
        run.create_run_button(
            RunContext.Selection,
            _("Run &to line"),
            tip=_("Run selection up to the current line"),
            shortcut_context=self.NAME,
            register_shortcut=True,
            add_to_toolbar=False,
            add_to_menu=True,
            context_modificator=SelectionContextModificator.ToLine
        )
        run.create_run_button(
            RunContext.Selection,
            _("Run &from line"),
            tip=_("Run selection from the current line"),
            shortcut_context=self.NAME,
            register_shortcut=True,
            add_to_toolbar=False,
            add_to_menu=True,
            context_modificator=SelectionContextModificator.FromLine
        )

        self.get_widget().add_run_actions_to_codeeditor_context_menu()

    @on_plugin_teardown(plugin=Plugins.Run)
    def on_run_teardown(self):
        widget = self.get_widget()
        run = self.get_plugin(Plugins.Run)

        widget.remove_run_actions_from_codeeditor_context_menu()

        run.deregister_run_configuration_provider(
            self.NAME, widget.supported_run_extensions
        )

        run.destroy_run_button(RunContext.Cell)
        run.destroy_run_button(
            RunContext.Cell,
            extra_action_name=ExtraAction.Advance
        )
        run.destroy_run_button(RunContext.Cell, re_run=True)
        run.destroy_run_button(
            RunContext.Selection,
            extra_action_name=ExtraAction.Advance
        )
        run.destroy_run_button(
            RunContext.Selection,
            context_modificator=SelectionContextModificator.ToLine
        )
        run.destroy_run_button(
            RunContext.Selection,
            context_modificator=SelectionContextModificator.FromLine
        )

    @on_plugin_available(plugin=Plugins.MainMenu)
    def on_mainmenu_available(self):
        widget = self.get_widget()
        mainmenu = self.get_plugin(Plugins.MainMenu)
        # ---- File menu ----
        # Print
        print_actions = [
            widget.print_preview_action,
            widget.print_action,
        ]
        for print_action in print_actions:
            mainmenu.add_item_to_application_menu(
                print_action,
                menu_id=ApplicationMenus.File,
                section=FileMenuSections.Print,
                before_section=FileMenuSections.Close
            )

        # Navigation
        if sys.platform == 'darwin':
            tab_navigation_actions = [
                widget.go_to_previous_file_action,
                widget.go_to_next_file_action
            ]
            for tab_navigation_action in tab_navigation_actions:
                mainmenu.add_item_to_application_menu(
                    tab_navigation_action,
                    menu_id=ApplicationMenus.File,
                    section=FileMenuSections.Navigation,
                    before_section=FileMenuSections.Restart
                )

        # ---- Edit menu ----
        edit_menu = mainmenu.get_application_menu(ApplicationMenus.Edit)
        edit_menu.aboutToShow.connect(widget.update_edit_actions)

        # Editor section
        for edit_item in widget.edit_menu_actions:
            mainmenu.add_item_to_application_menu(
                edit_item,
                menu_id=ApplicationMenus.Edit,
                section=EditMenuSections.Editor,
                before_section=EditMenuSections.Formatting,
            )

        # Formatting section
        formatting_actions = [
            widget.eol_menu,
            widget.trailingspaces_action,
            widget.fixindentation_action,
        ]
        for formatting_item in formatting_actions:
            mainmenu.add_item_to_application_menu(
                formatting_item,
                menu_id=ApplicationMenus.Edit,
                section=EditMenuSections.Formatting,
            )

        # ---- Search menu ----
        # Cursor section
        cursor_actions = [
            widget.previous_edit_cursor_action,
            widget.previous_cursor_action,
            widget.next_cursor_action,
        ]
        for cursor_item in cursor_actions:
            mainmenu.add_item_to_application_menu(
                cursor_item,
                menu_id=ApplicationMenus.Search,
                section=SearchMenuSections.Cursor,
                before_section=SearchMenuSections.FindInFiles,
            )

        # Options section
        option_actions = widget.checkable_actions.values()
        for option_item in option_actions:
            mainmenu.add_item_to_application_menu(
                option_item,
                menu_id=ApplicationMenus.Source,
                section=SourceMenuSections.Options,
                before_section=SourceMenuSections.Linting,
            )

        # Linting section
        linting_actions = [
            widget.todo_list_action,
            widget.warning_list_action,
            widget.previous_warning_action,
            widget.next_warning_action,
        ]
        for linting_item in linting_actions:
            mainmenu.add_item_to_application_menu(
                linting_item,
                menu_id=ApplicationMenus.Source,
                section=SourceMenuSections.Linting,
                before_section=SourceMenuSections.Autofix,
            )

        # Autofix section
        autofix_actions = [
            widget.formatting_action,
        ]
        for autofix_item in autofix_actions:
            mainmenu.add_item_to_application_menu(
                autofix_item,
                menu_id=ApplicationMenus.Source,
                section=SourceMenuSections.Autofix,
            )

    @on_plugin_teardown(plugin=Plugins.MainMenu)
    def on_mainmenu_teardown(self):
        widget = self.get_widget()
        mainmenu = self.get_plugin(Plugins.MainMenu)
        # ---- File menu ----
        # Print
        print_actions = [
            widget.print_preview_action,
            widget.print_action,
        ]
        for print_action in print_actions:
            mainmenu.remove_item_from_application_menu(
                print_action,
                menu_id=ApplicationMenus.File
            )

        # Navigation
        if sys.platform == 'darwin':
            tab_navigation_actions = [
                widget.go_to_previous_file_action,
                widget.go_to_next_file_action
            ]
            for tab_navigation_action in tab_navigation_actions:
                mainmenu.remove_item_from_application_menu(
                    tab_navigation_action,
                    menu_id=ApplicationMenus.File
                )

        # ---- Edit menu ----
        edit_menu = mainmenu.get_application_menu(ApplicationMenus.Edit)
        edit_menu.aboutToShow.disconnect(widget.update_edit_actions)

        # Editor section
        for edit_item in widget.edit_menu_actions:
            mainmenu.remove_item_from_application_menu(
                edit_item,
                menu_id=ApplicationMenus.Edit
            )

        # Formatting section
        formatting_actions = [
            widget.eol_menu,
            widget.trailingspaces_action,
            widget.fixindentation_action,
        ]
        for formatting_item in formatting_actions:
            mainmenu.remove_item_from_application_menu(
                formatting_item,
                menu_id=ApplicationMenus.Edit
            )

        # ---- Search menu ----
        search_menu = mainmenu.get_application_menu(ApplicationMenus.Search)
        search_menu.aboutToShow.disconnect(widget.update_search_menu)

        # Find section
        for search_item in widget.search_menu_actions:
            mainmenu.remove_item_from_application_menu(
                search_item,
                menu_id=ApplicationMenus.Search
            )

        # Cursor section
        cursor_actions = [
            widget.previous_edit_cursor_action,
            widget.previous_cursor_action,
            widget.next_cursor_action,
        ]
        for cursor_item in cursor_actions:
            mainmenu.remove_item_from_application_menu(
                cursor_item,
                menu_id=ApplicationMenus.Search
            )

        # Options section
        option_actions = widget.checkable_actions.values()
        for option_item in option_actions:
            mainmenu.remove_item_from_application_menu(
                option_item,
                menu_id=ApplicationMenus.Source
            )

        # Linting section
        linting_actions = [
            widget.todo_list_action,
            widget.warning_list_action,
            widget.previous_warning_action,
            widget.next_warning_action,
        ]
        for linting_item in linting_actions:
            mainmenu.remove_item_from_application_menu(
                linting_item,
                menu_id=ApplicationMenus.Source
            )

        # Autofix section
        autofix_actions = [
            widget.formatting_action,
        ]
        for autofix_item in autofix_actions:
            mainmenu.remove_item_from_application_menu(
                autofix_item,
                menu_id=ApplicationMenus.Source
            )

    @on_plugin_available(plugin=Plugins.Toolbar)
    def on_toolbar_available(self):
        widget = self.get_widget()
        toolbar = self.get_plugin(Plugins.Toolbar)
        toolbar.add_item_to_application_toolbar(
            widget.create_new_cell,
            toolbar_id=ApplicationToolbars.File,
        )

    @on_plugin_teardown(plugin=Plugins.Toolbar)
    def on_toolbar_teardown(self):
        toolbar = self.get_plugin(Plugins.Toolbar)
        toolbar.remove_item_from_application_toolbar(
            EditorWidgetActions.NewCell,
            toolbar_id=ApplicationToolbars.File,
        )

    @on_plugin_available(plugin=Plugins.Completions)
    def on_completions_available(self):
        widget = self.get_widget()
        completions = self.get_plugin(Plugins.Completions)

        widget.sig_after_configuration_update_requested.connect(
            completions.after_configuration_update
        )
        self.sig_file_opened_closed_or_updated.connect(
            completions.file_opened_closed_or_updated
        )

        completions.sig_language_completions_available.connect(
            widget.register_completion_capabilities)
        completions.sig_open_file.connect(widget.load)
        completions.sig_stop_completions.connect(
            widget.stop_completion_services)

    @on_plugin_teardown(plugin=Plugins.Completions)
    def on_completions_teardown(self):
        widget = self.get_widget()
        completions = self.get_plugin(Plugins.Completions)

        widget.sig_after_configuration_update_requested.disconnect(
            completions.after_configuration_update
        )
        self.sig_file_opened_closed_or_updated.disconnect(
            completions.file_opened_closed_or_updated
        )

        completions.sig_language_completions_available.disconnect(
            widget.register_completion_capabilities)
        completions.sig_open_file.disconnect(widget.load)
        completions.sig_stop_completions.disconnect(
            widget.stop_completion_services)

    @on_plugin_available(plugin=Plugins.OutlineExplorer)
    def on_outlineexplorer_available(self):
        widget = self.get_widget()
        outline = self.get_plugin(Plugins.OutlineExplorer)
        outline_widget = outline.get_widget()

        widget.set_outlineexplorer(outline_widget)

    @on_plugin_teardown(plugin=Plugins.OutlineExplorer)
    def on_outlinexplorer_teardown(self):
        self.get_widget().set_outlineexplorer(None)

    @on_plugin_available(plugin=Plugins.IPythonConsole)
    def on_ipyconsole_available(self):
        widget = self.get_widget()
        ipyconsole = self.get_plugin(Plugins.IPythonConsole)

        ipyconsole.register_spyder_kernel_call_handler(
            'cell_count', widget.handle_cell_count
        )
        ipyconsole.register_spyder_kernel_call_handler(
            'current_filename', widget.handle_current_filename
        )
        ipyconsole.register_spyder_kernel_call_handler(
            'get_file_code', widget.handle_get_file_code
        )
        ipyconsole.register_spyder_kernel_call_handler(
            'run_cell', widget.handle_run_cell
        )

    @on_plugin_teardown(plugin=Plugins.IPythonConsole)
    def on_ipyconsole_teardown(self):
        ipyconsole = self.get_plugin(Plugins.IPythonConsole)

        ipyconsole.unregister_spyder_kernel_call_handler('cell_count')
        ipyconsole.unregister_spyder_kernel_call_handler('current_filename')
        ipyconsole.unregister_spyder_kernel_call_handler('get_file_code')
        ipyconsole.unregister_spyder_kernel_call_handler('run_cell')

    @on_plugin_available(plugin=Plugins.Switcher)
    def on_switcher_available(self):
        switcher = self.get_plugin(Plugins.Switcher)
        self.get_widget().set_switcher(switcher)

    @on_plugin_teardown(plugin=Plugins.Switcher)
    def on_switcher_teardown(self):
        self.get_widget().set_switcher(None)

    @on_plugin_available(plugin=Plugins.Projects)
    def on_projects_available(self):
        projects = self.get_plugin(Plugins.Projects)
        projects.sig_project_loaded.connect(self._on_project_loaded)
        projects.sig_project_closed.connect(self._on_project_closed)

    @on_plugin_teardown(plugin=Plugins.Projects)
    def on_projects_teardown(self):
        projects = self.get_plugin(Plugins.Projects)
        projects.sig_project_loaded.disconnect(self._on_project_loaded)
        projects.sig_project_closed.disconnect(self._on_project_closed)

    @on_plugin_available(plugin=Plugins.Application)
    def on_application_available(self):
        application = self.get_plugin(Plugins.Application)
        widget = self.get_widget()

        widget.sig_new_recent_file.connect(application.add_recent_file)
        widget.sig_file_action_enabled.connect(self._enable_file_action)
        widget.sig_edit_action_enabled.connect(self._enable_edit_action)

        # Enable Select All edit action
        self._enable_edit_action(ApplicationActions.SelectAll, True)

        # Enable Search actions
        self._enable_search_action(ApplicationActions.FindText, True)
        self._enable_search_action(ApplicationActions.FindNext, True)
        self._enable_search_action(ApplicationActions.FindPrevious, True)
        self._enable_search_action(ApplicationActions.ReplaceText, True)

        self.get_widget().add_application_actions_to_codeeditor_context_menu()

    @on_plugin_teardown(plugin=Plugins.Application)
    def on_application_teardown(self):
        application = self.get_plugin(Plugins.Application)
        widget = self.get_widget()

        widget.remove_application_actions_from_codeeditor_context_menu()
        widget.sig_new_recent_file.disconnect(application.add_recent_file)
        widget.sig_file_action_enabled.disconnect(self._enable_file_action)
        widget.sig_edit_action_enabled.disconnect(self._enable_edit_action)

    def update_font(self):
        """Update font from Preferences"""
        font = self.get_font(SpyderFontType.Monospace)
        self.get_widget().update_font(font)

    def before_mainwindow_visible(self):
        # Don't move this to on_mainwindow_visible because the window appears
        # empty while the recovery dialog is shown.
        self.get_widget().autosave.try_recover_from_autosave()

    def on_mainwindow_visible(self):
        widget = self.get_widget()
        widget.restore_scrollbar_position()

    def can_close(self):
        editorstack = self.get_widget().editorstacks[0]
        return editorstack.save_if_changed(cancelable=True)

    def on_close(self, cancelable=False):
        widget = self.get_widget()

        if not self.get_widget().get_active_project_path():
            filenames = widget.get_filenames()
            self.set_conf('filenames', filenames)

    # ---- Public API
    # ------------------------------------------------------------------------
    def get_codeeditor_for_filename(self, filename):
        """
        Get `CodeEditor` instance associated with the given filename.

        Parameters
        ----------
        filename : str
            File path associated with a CodeEditor instance.

        Returns
        -------
        spyder.plugins.editor.codeeditor.CodeEditor
            `CodeEditor` associated with the given filename.
        """
        return self.get_widget().get_editor(filename)

    def refresh(self):
        """
        Refresh main widget.
        """
        self.get_widget().refresh()

    def load(self, *args, **kwargs):
        """
        Load a file or a group of files.

        Parameters
        ----------
        filenames: Optional[list]
            Filenames to load.
        goto: Optional[int]
            If goto is not None, it represents a line to go to. Used alongside
            `start_column` and `end_column`. Alternatively, the first match of
            `word` is used as a position.
        word: Optional[str]
            The `word` to use to set the cursor position when using `goto`.
        editorwindow: Optional[spyder.plugins.editor.widgets.window.EditorMainWindow]  # noqa
            Load in the given editorwindow (useful when clicking in the Outline
            explorer with multiple editor windows).
        processevents: Optional[bool]
            Determines if `processEvents()` should be called at the end of this
            method (set to `False` to prevent keyboard events from creeping
            through to the editor while debugging).
        start_column: Optional[int]
            The start position in the line (goto)
        end_column: Optional[int]
            The length (so that the end position is `start_column` +
            `end_column`), when providing a `goto` line.
        set_focus: Optional[bool]
            If the opened file should gain focus. `True` by default.
        add_where: Optional[str]
            Position where to add the new file finfo (affects the files tab
            order). Possible values are: `start` to make the file the first and
             `end` (or any other value) to append.
        """
        return self.get_widget().load(*args, **kwargs)

    def load_edit(self, filename):
        """
        Load a `filename` passing to the base `load` method the `main_widget`
        as the `editorwindow` to force focus.

        Used by `spyder.plugins.outlineexplorer.plugin.[on_editor_available|on_editor_teardown]`  # noqa

        Parameters
        ----------
        filename: str
            Filename to load.
        """
        widget = self.get_widget()
        return self.get_widget().load(filenames=filename, editorwindow=widget)

    def load_edit_goto(self, filename, goto, word):
        """
        Load a `filename` and put the cursor in the line given by `goto` and
        `word`, passing to the `load` call the `main_widget` as the
        `editorwindow` to force focus.

        Used by `spyder.plugins.outlineexplorer.plugin.[on_editor_available|on_editor_teardown]`  # noqa

        Parameters
        ----------
        filename: str
            Filename to load.
        goto: int
            Represents a line to go to.
        word: str
            The `word` to use to set the cursor position when using `goto`.
        """
        widget = self.get_widget()
        return widget.load(
            filenames=filename, goto=goto, word=word, editorwindow=widget
        )

    def open_last_closed(self) -> None:
        """
        Open the last closed tab again.
        """
        return self.get_widget().open_last_closed()

    def new(self, *args, **kwargs):
        """
        Create a new file.

        Parameters
        ----------
        fname: Optional[str]
            Name of the file to be created. The default is `None`.
            If `None`, `fname` will be named `untitledXX.py`. No actual file
            will be created until it is saved manually by the user.
        editorstack: Optional[spyder.plugins.editor.widgets.editorstack.EditorStack]  # noqa
            Reference to the `EditorStack` instance that will be used to:
                * Get `untitledXX.py` numbering for the file name.
                * Check if a file with the same name already exists and it is
                  closeable.
                * Set file as the current focused file.
            The default is `None`. If that's the case, the current
            `EditorStack` is used. See the `get_current_editorstack` method for
            more details.
        text: Optional[str]
            Base text content that will be added to the file. The default is
            `None`. If that's the case, the default content created will be
            created via a template file. See
            `Preferences > Editor > Advanced settings > Edit template for new files`  # noqa
        """
        return self.get_widget().new(*args, **kwargs)

    def removed(self, filename):
        """
        Close file given his filename since it was removed.

        It's used, for instance, when a file was removed in the File or Project
        explorer plugins.

        Parameters
        ----------
        filename: str
            File path to be closed/removed.
        """
        return self.get_widget().removed(filename)

    def removed_tree(self, dirname):
        """
        Close files given a directory since it was removed.

        It's used, for instance, when a directory was removed in the File or
        Project explorer plugins.

        Parameters
        ----------
        dirname: str
            Base directory path of the files to be closed/removed.
        """
        return self.get_widget().removed_tree(dirname)

    def renamed(self, *args, **kwargs):
        """
        Propagate file rename to editor stacks and autosave component.

        This method is called when a file is renamed in the File or Project
        explorer plugins. The file may not be opened in the editor.

        Parameters
        ----------
        source: str
            Initial filename path.
        dest: str
            New filename path.
        editorstack_id_str: Optional[str]
            The default is `None`. If not, the `EditorStack` instance whose
            identity corresponds to `editorstack_id_str` **doesn't** perform
            the file rename operation.
        """
        return self.get_widget().renamed(*args, **kwargs)

    def renamed_tree(self, *args, **kwargs):
        """
        Propagate directory rename to editor stacks and autosave component.

        This is used when the directory was renamed in File or Project explorer
        plugins.

        Parameters
        ----------
        source: str
            Initial directory path.
        dest: str
            New directory path.
        """
        return self.get_widget().renamed_tree(*args, **kwargs)

    def add_supported_run_configuration(self, *args, **kwargs):
        """
        Add a run configuration schema supported by the Editor.

        Parameters
        ----------
        config : spyder.plugins.editor.api.run.EditorRunConfiguration
            New run configuration schema to be added.
        """
        return self.get_widget().add_supported_run_configuration(
            *args, **kwargs
        )

    def remove_supported_run_configuration(self, *args, **kwargs):
        """
        Remove a run configuration schema supported by the Editor.

        Parameters
        ----------
        config : spyder.plugins.editor.api.run.EditorRunConfiguration
            Run configuration schema to be removed.
        """
        return self.get_widget().remove_supported_run_configuration(
            *args, **kwargs
        )

    def get_current_editor(self):
        """
        Get current `CodeEditor` instance if available.

        Returns
        -------
        spyder.plugins.editor.codeeditor.CodeEditor
            `CodeEditor` instance focused or available.
        """
        return self.get_widget().get_current_editor()

    def get_current_editorstack(self):
        """
        Get current `EditorStack` instance if available.

        Returns
        -------
        spyder.plugins.editor.editorstack.EditorStack
            `EditorStack` instance focused or available.
        """
        return self.get_widget().get_current_editorstack()

    def get_focus_widget(self):
        """
        Return the widget to give focus to.

        This happens when plugin's main widget is raised to the top-level.

        Returns
        -------
        spyder.plugins.editor.codeeditor.CodeEditor
            `CodeEditor` instance focused or available.
        """
        return self.get_widget().get_focus_widget()

    def setup_open_files(self,  close_previous_files=True):
        """
        Open the list of saved files per project.

        Also, open any files that the user selected in the recovery dialog and
        setup toolbars and menus for 'New window' instances (i.e. it calls the
        `setup_other_windows` method).

        Parameters
        ----------
        close_previous_files : Optional[bool]
            If any previously open file should be closed. Default `True`.
        """
        widget = self.get_widget()
        outline = self.get_plugin(Plugins.OutlineExplorer, error=False)
        if outline:
            widget.setup_other_windows(self._main, outline)
        return self.get_widget().setup_open_files(
            close_previous_files=close_previous_files
        )

    def save_open_files(self,):
        """Save the list of open files."""
        return self.get_widget().save_open_files()

    def save(self, index=None, force=False):
        """
        Save file.

        Parameters
        ----------
        index : Optional[int]
            Index related to the file position in the current editorstack.
            The default is `None`, which uses the current file index.
        force : Optional[bool]
            Force save regardless of file state. The default is `False`.

        Returns
        -------
        bool
            `True` if the save operation was sucessfull. `False` otherwise.
        """
        return self.get_widget().save(index=None, force=False)

    def save_all(self) -> None:
        """
        Save all files.
        """
        return self.get_widget().save_all()

    def save_as(self) -> None:
        """
        Save all files.
        """
        self.get_widget().save_as()

    def save_copy_as(self) -> None:
        """
        Save copy of file under a different name.
        """
        self.get_widget().save_copy_as()

    def revert_file(self) -> None:
        """
        Revert the currently edited file from disk.
        """
        self.get_widget().revert()

    def save_bookmark(self, slot_num):
        """
        Save current line and position as bookmark.

        Parameters
        ----------
        slot_num : int
        """
        return self.get_widget().save_bookmark(slot_num)

    def load_bookmark(self, slot_num):
        """
        Set cursor to bookmarked file and position.

        Parameters
        ----------
        slot_num : int
        """
        return self.get_widget().load_bookmark(slot_num)

    def edit_template(self):
        """Edit `New file` template."""
        return self.get_widget().edit_template()

    def get_current_filename(self):
        """Get current editor 'filename'."""
        return self.get_widget().get_current_filename()

    def current_file_is_temporary(self) -> bool:
        """Return whether file in current editor is a temporary file."""
        return self.get_current_editor() == self.get_widget().TEMPFILE_PATH

    def get_filenames(self):
        """
        Get list with all open files.

        Returns
        -------
        list
            A list with the names of all files currently opened in
            the editorstack.
        """
        return self.get_widget().get_filenames()

    def close_file(self):
        """Close current file."""
        return self.get_widget().close_file()

    def close_file_from_name(self, filename):
        """
        Close file from its name.

        Parameters
        ----------
        filename : str
            Filename to be closed.
        """
        return self.get_widget().close_file_from_name(filename)

    def close_all_files(self):
        """Close all opened files."""
        return self.get_widget().close_all_files()

    def go_to_line(self, line=None):
        """
        Open 'go to line' dialog.

        Parameters
        ----------
        line : Optional[int]
            Line to use for programatic calls without showing the dialog. The
            default is `None`.
        """
        return self.get_widget().go_to_line(line=line)

    def set_current_filename(self, *args, **kwargs):
        """
        Set current filename.

        Returns
        -------
        spyder.plugins.editor.codeeditor.CodeEditor
            The associated `CodeEditor` instance.
        """
        return self.get_widget().set_current_filename(*args, **kwargs)

    def set_current_project_path(self, root_path=None):
        """
        Set the current active project root path.

        Parameters
        ----------
        root_path: Optional[str]
            Path to current project root path. Default is `None`.
        """
        return self.get_widget().set_current_project_path(root_path=root_path)

    def undo(self) -> None:
        return self.get_widget().undo()

    def redo(self) -> None:
        return self.get_widget().redo()

    def cut(self) -> None:
        return self.get_widget().cut()

    def copy(self) -> None:
        return self.get_widget().copy()

    def paste(self) -> None:
        return self.get_widget().paste()

    def select_all(self) -> None:
        return self.get_widget().select_all()

    def find(self) -> None:
        return self.get_widget().find()

    def find_next(self) -> None:
        return self.get_widget().find_next()

    def find_previous(self) -> None:
        return self.get_widget().find_previous()

    def replace(self) -> None:
        return self.get_widget().replace()

    # ---- Private API
    # ------------------------------------------------------------------------
    # ---- Run related methods
    def _register_run_configuration_metadata(self, metadata):
        run = self.get_plugin(Plugins.Run, error=False)
        if run is not None:
            run.register_run_configuration_metadata(
                self.get_widget(), metadata
            )

    def _deregister_run_configuration_metadata(self, file_id):
        run = self.get_plugin(Plugins.Run, error=False)
        if run is not None:
            run.deregister_run_configuration_metadata(file_id)

    def _get_currently_selected_run_configuration(self):
        run = self.get_plugin(Plugins.Run, error=False)
        if run is not None:
            return run.get_currently_selected_configuration()

    def _switch_focused_run_configuration(self, file_id):
        run = self.get_plugin(Plugins.Run, error=False)
        if run is not None:
            run.switch_focused_run_configuration(file_id)

    # ---- Completions related methods
    def _register_file_completions(self, language, filename, codeeditor):
        completions = self.get_plugin(Plugins.Completions, error=False)
        status = None
        fallback_only = False
        if completions is not None:
            status = (
                completions.start_completion_services_for_language(
                    language.lower()
                )
            )
            completions.register_file(
                language.lower(), filename, codeeditor
            )
            fallback_only = completions.is_fallback_only(language.lower())
        return (status, fallback_only)

    def _send_completions_request(self, language, request, params):
        completions = self.get_plugin(Plugins.Completions, error=False)
        if completions is not None:
            completions.send_request(language, request, params)

    def _after_configuration_update(self, config):
        completions = self.get_plugin(Plugins.Completions, error=False)
        if completions is not None:
            completions.after_configuration_update(config)

    # ---- Projects related methods
    def _start_project_workspace_services(self):
        projects = self.get_plugin(Plugins.Projects, error=False)
        if projects is not None:
            projects.start_workspace_services()

    def _get_project_filenames(self):
        if self.get_widget().get_active_project_path():
            projects = self.get_plugin(Plugins.Projects, error=False)
            return projects.get_project_filenames()

    def _on_project_loaded(self, path):
        self.get_widget().update_active_project_path(path)

    def _on_project_closed(self):
        self.get_widget().update_active_project_path(None)

    # ---- Debugger related methods
    def _debugger_close_file(self, filename):
        debugger = self.get_plugin(Plugins.Debugger, error=False)
        if debugger is None:
            return True
        return debugger.can_close_file(filename)

    # ---- Methods related to the Application plugin
    # ------------------------------------------------------------------------
    def _enable_file_action(self, action_name: str, enabled: bool) -> None:
        """
        Enable or disable file action for this plugin.
        """
        application = self.get_plugin(Plugins.Application, error=False)
        if application:
            application.enable_file_action(action_name, enabled, self.NAME)

    def _enable_edit_action(self, action_name: str, enabled: bool) -> None:
        """Enable or disable edit action for this plugin."""
        application = self.get_plugin(Plugins.Application, error=False)
        if application:
            application.enable_edit_action(action_name, enabled, self.NAME)

    def _enable_search_action(self, action_name: str, enabled: bool) -> None:
        """Enable or disable search action for this plugin."""
        application = self.get_plugin(Plugins.Application, error=False)
        if application:
            application.enable_search_action(action_name, enabled, self.NAME)
