"""
This module contains the file system tree view.
"""
import sys
import fnmatch
import locale
import logging
import os
import platform
import shutil
import subprocess
from qtpy import QtCore, QtGui, QtWidgets
from pyqodeng.core import icons


def _logger():
    return logging.getLogger(__name__)


def debug(msg, *args):
    return _logger().log(5, msg, *args)


class FileSystemTreeView(QtWidgets.QTreeView):
    """
    Extends QtWidgets.QTreeView with a filterable file system model.

    To exclude directories or extension, just set
    :attr:`FilterProxyModel.ignored_directories` and
    :attr:`FilterProxyModel.ignored_extensions`.

    Provides methods to retrieve file info from model index.

    By default there is no context menu and no file operations are possible. We
    provide a standard context menu with basic file system operation (
    :class:`FileSystemContextMenu`) that you can extend and
    set on the tree view using :meth:`FileSystemTreeView.set_context_menu`

    """
    class FilterProxyModel(QtCore.QSortFilterProxyModel):
        """
        Excludes :attr:`ignored_directories` and :attr:`ignored_extensions`
        from the file system model.
        """
        def __init__(self):
            super(FileSystemTreeView.FilterProxyModel, self).__init__()
            #: The list of file extension to exclude
            self.ignored_patterns = [
                '*.pyc', '*.pyo', '*.coverage', '.DS_Store', '__pycache__']
            self._ignored_unused = []

        def set_root_path(self, path):
            """
            Sets the root path to watch.
            :param path: root path (str).
            """
            self._ignored_unused[:] = []
            self._root = path
            parent_dir = os.path.dirname(path)
            for item in os.listdir(parent_dir):
                item_path = os.path.join(parent_dir, item)
                if item_path != path:
                    self._ignored_unused.append(os.path.normpath(item_path))

        def filterAcceptsRow(self, row, parent):
            index0 = self.sourceModel().index(row, 0, parent)
            finfo = self.sourceModel().fileInfo(index0)
            fn = finfo.fileName()
            fp = os.path.normpath(finfo.filePath())
            if os.path.ismount(self._root):
                return True
            if fp in self._ignored_unused:
                return False
            for ptrn in self.ignored_patterns:
                if fnmatch.fnmatch(fn, ptrn):
                    return False
            debug('accepting %s', finfo.filePath())
            return True

    #: signal emitted when the user deleted a file or a directory
    #: Deprecated, use files_deleted instead.
    #: Parameters:
    #: - path (str): path of the file that got deleted
    #: Note that if the removed path is a directory, this signal will be emitted for every file
    #: found recursively in the parent directory
    file_deleted = QtCore.Signal(str)

    #: Signal emitted when the user deleted a file or a directory,
    #: it is emitted only once with all the files deleted.
    files_deleted = QtCore.Signal(list)

    #: signal emitted when the user renamed a file or a directory
    #: Deprecated, use files_renamed instead.
    #: Parameters:
    #: - old (str): old path
    #: - new (str): new path
    file_renamed = QtCore.Signal(str, str)

    #: Signal emitted when the user renamed a file or a directory,
    #: it is emitted once with all the renamed files (not directgories)
    files_renamed = QtCore.Signal(list)

    #: signal emitted when the user created a file
    #: Parameters:
    #: - path (str): path of the file that got created
    file_created = QtCore.Signal(str)

    #: signal emitted just before the context menu is shown
    #: Parameters:
    #:   - file path: current file path.
    about_to_show_context_menu = QtCore.Signal(str)

    def __init__(self, parent=None):
        super(FileSystemTreeView, self).__init__(parent)
        self._path_to_set = None
        self._path_to_select = None
        self.context_menu = None
        self._root_path = None
        self.root_path = ''
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self._show_context_menu)
        self.helper = FileSystemHelper(self)
        self.setSelectionMode(self.ExtendedSelection)
        self._ignored_patterns = []
        self._icon_provider = QtWidgets.QFileIconProvider()
        self._hide_extra_colums = True
        from pyqodeng.core.widgets import FileIconProvider
        self.set_icon_provider(FileIconProvider())

    def showEvent(self, event):
        super(FileSystemTreeView, self).showEvent(event)
        if self._path_to_set:
            self.set_root_path(self._path_to_set, self._hide_extra_colums)
            self._path_to_set = None

    def set_icon_provider(self, icon_provider):
        self._icon_provider = icon_provider

    def ignore_directories(self, *directories):
        """
        Adds the specified directories to the list of ignored directories.

        This must be done before calling set_root_path!

        .. deprecated:: 2.6.1
            Use :func:`add_ignore_pattern` instead.

        :param directories: the directories to ignore
        """
        for d in directories:
            self.add_ignore_patterns(d)

    def ignore_extensions(self, *extensions):
        """
        Adds the specified extensions to the list of ignored directories.

        This must be done before calling set_root_path!


        .. deprecated:: 2.6.1
            Use :func:`add_ignore_pattern` instead.

        :param extensions: the extensions to ignore

        .. note:: extension must have the dot: '.py' and not 'py'
        """
        for ext in extensions:
            self.add_ignore_patterns('*%s' % ext)

    def clear_ignore_patterns(self):
        """
        Clears the list of ignore patterns
        """
        self._ignored_patterns[:] = []

    def add_ignore_patterns(self, *patterns):
        """
        Adds an ignore pattern to the list for ignore patterns.

        Ignore patterns are used to filter out unwanted files or directories
        from the file system model.

        A pattern is a Unix shell-style wildcards. See :mod:`fnmatch` for a
        deeper explanation about the shell-style wildcards.
        """
        for ptrn in patterns:
            if isinstance(ptrn, list):
                for p in ptrn:
                    self._ignored_patterns.append(p)
            else:
                self._ignored_patterns.append(ptrn)

    def set_context_menu(self, context_menu):
        """
        Sets the context menu of the tree view.

        :param context_menu: QMenu
        """
        self.context_menu = context_menu
        self.context_menu.tree_view = self
        self.context_menu.init_actions()
        for action in self.context_menu.actions():
            self.addAction(action)

    def set_root_path(self, path, hide_extra_columns=True):
        """
        Sets the root path to watch
        :param str path: root path
        :param hide_extra_columns: Hide extra column (size, paths,...)
        """
        if not self.isVisible():
            self._path_to_set = path
            self._hide_extra_colums = hide_extra_columns
            return
        if sys.platform == 'win32' and path.startswith("\\\\"):
            mdl = QtGui.QStandardItemModel(1, 1)
            item = QtGui.QStandardItem(
                QtGui.QIcon.fromTheme(
                    'dialog-warning',
                    QtGui.QIcon(':/pyqode-icons/rc/dialog-warning.png')),
                'UNC pathnames not supported.')
            mdl.setItem(0, 0, item)
            self.setModel(mdl)
            self.root_path = None
            return
        self._hide_extra_colums = hide_extra_columns

        if os.path.isfile(path):
            path = os.path.abspath(os.path.join(path, os.pardir))
        self._fs_model_source = QtWidgets.QFileSystemModel()
        self._fs_model_source.setFilter(QtCore.QDir.Dirs | QtCore.QDir.Files |
                                        QtCore.QDir.NoDotAndDotDot |
                                        QtCore.QDir.Hidden)
        self._fs_model_source.setIconProvider(self._icon_provider)
        self._fs_model_proxy = self.FilterProxyModel()
        for item in self._ignored_patterns:
            self._fs_model_proxy.ignored_patterns.append(item)
        self._fs_model_proxy.setSourceModel(self._fs_model_source)
        self._fs_model_proxy.set_root_path(path)
        # takes parent of the root path, filter will keep only `path`, that
        # way `path` appear as the top level node of the tree
        self._root_path = os.path.dirname(path)
        self.root_path = path
        self._fs_model_source.directoryLoaded.connect(self._on_path_loaded)
        self._fs_model_source.setRootPath(self._root_path)

    def _on_path_loaded(self, path):
        if os.path.normpath(path) != self._root_path:
            return
        try:
            self.setModel(self._fs_model_proxy)
            file_root_index = self._fs_model_source.setRootPath(
                self._root_path)
            root_index = self._fs_model_proxy.mapFromSource(file_root_index)
            self.setRootIndex(root_index)
            if not os.path.ismount(self._root_path):
                self.expandToDepth(0)
            if self._hide_extra_colums:
                self.setHeaderHidden(True)
                for i in range(1, 4):
                    self.hideColumn(i)
            if self._path_to_select:
                self.select_path(self._path_to_select)
                self._path_to_select = None
        except RuntimeError:
            # wrapped C/C++ object of type FileSystemTreeView has been deleted
            return

    def filePath(self, index):
        """
        Gets the file path of the item at the specified ``index``.

        :param index: item index - QModelIndex
        :return: str
        """
        return self._fs_model_source.filePath(
            self._fs_model_proxy.mapToSource(index))

    def fileInfo(self, index):
        """
        Gets the file info of the item at the specified ``index``.

        :param index: item index - QModelIndex
        :return: QFileInfo
        """
        return self._fs_model_source.fileInfo(
            self._fs_model_proxy.mapToSource(index))

    def _show_context_menu(self, point):
        if self.context_menu:
            self.about_to_show_context_menu.emit(
                FileSystemHelper(self).get_current_path())
            self.context_menu.exec_(self.mapToGlobal(point))

    def select_path(self, path):
        if not self.isVisible():
            self._path_to_select = path
        else:
            self.setCurrentIndex(self._fs_model_proxy.mapFromSource(
                self._fs_model_source.index(path)))


class FileSystemHelper:
    """
    File system helper. Helps manipulating the clipboard for file operations
    on the tree view (drag & drop, context menu, ...).
    """
    class _UrlListMimeData(QtCore.QMimeData):
        def __init__(self, copy=True):
            super(FileSystemHelper._UrlListMimeData, self).__init__()
            self.copy = copy

        def set_list(self, urls):
            """
            Sets the lis of urls into the mime type data.
            """
            lst = []
            for url in urls:
                lst.append(bytes(url, encoding=locale.getpreferredencoding()))
            self.setData(self.format(self.copy), b'\n'.join(lst))

        @classmethod
        def list_from(cls, mime_data, copy=True):
            """
            Returns a list of url from mimetype data
            :param mime_data: mime data from which we must read the list of
                urls
            :param copy: True to copy, False to cut
            """
            string = bytes(mime_data.data(cls.format(copy))).decode('utf-8')
            lst = string.split('\n')
            urls = []
            for val in lst:
                urls.append(val)
            return urls

        def formats(self):
            return [self.format(self.copy)]

        @classmethod
        def format(cls, copy=True):
            return 'text/tv-copy-url-list' if copy else 'text/tv-cut-url-list'

    def __init__(self, treeview):
        self.tree_view = treeview

    def copy_to_clipboard(self, copy=True):
        """
        Copies the selected items to the clipboard
        :param copy: True to copy, False to cut.
        """
        urls = self.selected_urls()
        if not urls:
            return
        mime = self._UrlListMimeData(copy)
        mime.set_list(urls)
        clipboard = QtWidgets.QApplication.clipboard()
        clipboard.setMimeData(mime)

    def selected_urls(self):
        """
        Gets the list of selected items file path (url)
        """
        urls = []
        debug('gettings urls')
        for proxy_index in self.tree_view.selectedIndexes():
            finfo = self.tree_view.fileInfo(proxy_index)
            urls.append(finfo.canonicalFilePath())
        debug('selected urls %r' % [str(url) for url in urls])
        return urls

    def paste_from_clipboard(self):
        """
        Pastes files from clipboard.
        """
        to = self.get_current_path()
        if os.path.isfile(to):
            to = os.path.abspath(os.path.join(to, os.pardir))
        mime = QtWidgets.QApplication.clipboard().mimeData()

        paste_operation = None
        if mime.hasFormat(self._UrlListMimeData.format(copy=True)):
            paste_operation = True
        elif mime.hasFormat(self._UrlListMimeData.format(copy=False)):
            paste_operation = False
        if paste_operation is not None:
            self._paste(
                self._UrlListMimeData.list_from(mime, copy=paste_operation),
                to, copy=paste_operation)

    def _paste(self, sources, destination, copy):
        """
        Copies the files listed in ``sources`` to destination. Source are
        removed if copy is set to False.
        """
        for src in sources:
            debug('%s <%s> to <%s>' % (
                'copying' if copy else 'cutting', src, destination))
            perform_copy = True
            ext = os.path.splitext(src)[1]
            original = os.path.splitext(os.path.split(src)[1])[0]
            filename, status = QtWidgets.QInputDialog.getText(
                self.tree_view, _('Copy'), _('New name:'),
                QtWidgets.QLineEdit.Normal, original)
            if filename == '' or not status:
                return
            filename = filename + ext
            final_dest = os.path.join(destination, filename)
            if os.path.exists(final_dest):
                rep = QtWidgets.QMessageBox.question(
                    self.tree_view, _('File exists'),
                    _('File <%s> already exists. Do you want to erase it?') %
                    final_dest,
                    QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
                    QtWidgets.QMessageBox.No)
                if rep == QtWidgets.QMessageBox.No:
                    perform_copy = False
            if not perform_copy:
                continue
            try:
                if os.path.isfile(src):
                    shutil.copy(src, final_dest)
                else:
                    shutil.copytree(src, final_dest)
            except (IOError, OSError) as e:
                QtWidgets.QMessageBox.warning(
                    self.tree_view, _('Copy failed'), _('Failed to copy "%s" to "%s".\n\n%s' %
                                                        (src, destination, str(e))))
                _logger().exception('failed to copy "%s" to "%s', src,
                                    destination)
            else:
                debug('file copied %s', src)
            if not copy:
                debug('removing source (cut operation)')
                if os.path.isfile(src):
                    os.remove(src)
                else:
                    shutil.rmtree(src)
                self.tree_view.files_renamed.emit([(src, final_dest)])

    @staticmethod
    def _get_files(path):
        """
        Returns the list of files contained in path (recursively).
        """
        ret_val = []
        for root, _, files in os.walk(path):
            for f in files:
                ret_val.append(os.path.join(root, f))
        return ret_val

    def delete(self):
        """
        Deletes the selected items.
        """
        urls = self.selected_urls()
        rep = QtWidgets.QMessageBox.question(
            self.tree_view, _('Confirm delete'),
            _('Are you sure about deleting the selected files/directories?'),
            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
            QtWidgets.QMessageBox.Yes)
        if rep == QtWidgets.QMessageBox.Yes:
            deleted_files = []
            for fn in urls:
                try:
                    if os.path.isfile(fn):
                        os.remove(fn)
                        deleted_files.append(fn)
                    else:
                        files = self._get_files(fn)
                        shutil.rmtree(fn)
                        deleted_files += files
                except OSError as e:
                    QtWidgets.QMessageBox.warning(
                        self.tree_view, _('Delete failed'),
                        _('Failed to remove "%s".\n\n%s') % (fn, str(e)))
                    _logger().exception('failed to remove %s', fn)
            self.tree_view.files_deleted.emit(deleted_files)
            for d in deleted_files:
                debug('%s removed', d)
                self.tree_view.file_deleted.emit(os.path.normpath(d))

    def get_current_path(self):
        """
        Gets the path of the currently selected item.
        """
        path = self.tree_view.fileInfo(
            self.tree_view.currentIndex()).filePath()
        # https://github.com/pyQode/pyQode/issues/6
        if not path:
            path = self.tree_view.root_path
        return path

    def copy_path_to_clipboard(self):
        """
        Copies the file path to the clipboard
        """
        path = self.get_current_path()
        QtWidgets.QApplication.clipboard().setText(path)
        debug('path copied: %s' % path)

    def rename(self):
        """
        Renames the selected item in the tree view
        """
        src = self.get_current_path()
        pardir, name = os.path.split(src)
        new_name, status = QtWidgets.QInputDialog.getText(
            self.tree_view, _('Rename '), _('New name:'),
            QtWidgets.QLineEdit.Normal, name)
        if status:
            dest = os.path.join(pardir, new_name)
            old_files = []
            if os.path.isdir(src):
                old_files = self._get_files(src)
            else:
                old_files = [src]
            try:
                os.rename(src, dest)
            except OSError as e:
                QtWidgets.QMessageBox.warning(
                    self.tree_view, _('Rename failed'),
                    _('Failed to rename "%s" into "%s".\n\n%s') % (src, dest, str(e)))
            else:
                if os.path.isdir(dest):
                    new_files = self._get_files(dest)
                else:
                    new_files = [dest]
                self.tree_view.file_renamed.emit(os.path.normpath(src),
                                                 os.path.normpath(dest))
                renamed_files = []
                for old_f, new_f in zip(old_files, new_files):
                    self.tree_view.file_renamed.emit(old_f, new_f)
                    renamed_files.append((old_f, new_f))
                # emit all changes in one go
                self.tree_view.files_renamed.emit(renamed_files)

    def create_directory(self):
        """
        Creates a directory under the selected directory (if the selected item
        is a file, the parent directory is used).
        """
        src = self.get_current_path()
        name, status = QtWidgets.QInputDialog.getText(
            self.tree_view, _('Create directory'), _('Name:'),
            QtWidgets.QLineEdit.Normal, '')
        if status:
            fatal_names = ['.', '..']
            for i in fatal_names:
                if i == name:
                    QtWidgets.QMessageBox.critical(
                        self.tree_view, _("Error"), _("Wrong directory name"))
                    return

            if os.path.isfile(src):
                src = os.path.dirname(src)
            dir_name = os.path.join(src, name)
            try:
                os.makedirs(dir_name, exist_ok=True)
            except OSError as e:
                QtWidgets.QMessageBox.warning(
                    self.tree_view, _('Failed to create directory'),
                    _('Failed to create directory: "%s".\n\n%s') % (dir_name, str(e)))

    def create_file(self):
        """
        Creates a file under the current directory.
        """
        src = self.get_current_path()
        name, status = QtWidgets.QInputDialog.getText(
            self.tree_view, _('Create new file'), _('File name:'),
            QtWidgets.QLineEdit.Normal, '')
        if status:
            fatal_names = ['.', '..', os.sep]
            for i in fatal_names:
                if i == name:
                    QtWidgets.QMessageBox.critical(
                        self.tree_view, _("Error"), _("Wrong directory name"))
                    return

            if os.path.isfile(src):
                src = os.path.dirname(src)
            path = os.path.join(src, name)
            try:
                with open(path, 'w'):
                    pass
            except OSError as e:
                QtWidgets.QMessageBox.warning(
                    self.tree_view, _('Failed to create new file'),
                    _('Failed to create file: "%s".\n\n%s') % (path, str(e)))
            else:
                self.tree_view.file_created.emit(os.path.normpath(path))


class FileSystemContextMenu(QtWidgets.QMenu):
    """
    Default context menu for the file system treeview.

    This context menu contains the following actions:
        - Copy
        - Cut
        - Paste
        - Delete
        - Copy path

    .. note:: copy/cut/paste action works only from inside the application
        (e.g. you cannot paste what you copied in the app to the explorer)

    """
    _explorer = None
    _command = None

    def __init__(self):
        super(FileSystemContextMenu, self).__init__()
        #: Reference to the tree view
        self.tree_view = None

    def addAction(self, *args):
        action = super(FileSystemContextMenu, self).addAction(*args)
        if action is None:
            action = args[0]
        action.setShortcutContext(QtCore.Qt.WidgetShortcut)
        self.tree_view.addAction(action)
        return action

    def init_actions(self):
        # New - submenu
        self.menu_new = self.addMenu("&New")
        self.menu_new.setIcon(
            icons.icon('document-new', None, 'fa.plus'))
        # https://github.com/pyQode/pyqode.core/pull/153
        new_user_actions = self.get_new_user_actions()
        if len(new_user_actions) > 0:
            self.menu_new.addSeparator()
            for user_new_action in new_user_actions:
                self.menu_new.addAction(user_new_action)
        # New file
        self.action_create_file = QtWidgets.QAction(_('&File'), self)
        self.action_create_file.triggered.connect(
            self._on_create_file_triggered)
        icon_provider = self.tree_view._icon_provider
        self.action_create_file.setIcon(icon_provider.icon(
            icon_provider.File))
        self.menu_new.addAction(self.action_create_file)
        # New directory
        self.action_create_directory = QtWidgets.QAction(
            _('&Directory'), self)
        self.action_create_directory.triggered.connect(
            self._on_create_directory_triggered)
        self.action_create_directory.setIcon(icon_provider.icon(
            icon_provider.Folder))
        self.menu_new.addAction(self.action_create_directory)
        self.addSeparator()

        # cut
        self.action_cut = QtWidgets.QAction(_('&Cut'), self)
        self.action_cut.setShortcut(QtGui.QKeySequence.Cut)
        self.action_cut.setIcon(icons.icon(
            'edit-cut', ':/pyqode-icons/rc/edit-cut.png', 'fa.cut'))
        self.addAction(self.action_cut)
        self.action_cut.triggered.connect(self._on_cut_triggered)
        # copy
        self.action_copy = QtWidgets.QAction(_('&Copy'), self)
        self.action_copy.setShortcut(QtGui.QKeySequence.Copy)
        self.action_copy.setIcon(icons.icon(
            'edit-copy', ':/pyqode-icons/rc/edit-copy.png', 'fa.copy'))
        self.addAction(self.action_copy)
        self.action_copy.triggered.connect(self._on_copy_triggered)
        # copy path
        self.action_copy_path = QtWidgets.QAction(_('&Copy path'), self)
        self.action_copy_path.setShortcut('Ctrl+Shift+C')
        self.addAction(self.action_copy_path)
        self.action_copy_path.triggered.connect(self._on_copy_path_triggered)
        # Paste
        self.action_paste = QtWidgets.QAction(_('&Paste'), self)
        self.action_paste.setShortcut(QtGui.QKeySequence.Paste)
        self.action_paste.setIcon(icons.icon(
            'edit-paste', ':/pyqode-icons/rc/edit-paste.png', 'fa.paste'))
        self.action_paste.triggered.connect(self._on_paste_triggered)
        self.addAction(self.action_paste)
        self.addSeparator()
        # Rename
        self.action_rename = QtWidgets.QAction(_('&Rename'), self)
        self.action_rename.setShortcut('F2')
        self.action_rename.triggered.connect(self._on_rename_triggered)
        self.action_rename.setIcon(QtGui.QIcon.fromTheme('edit-rename'))
        self.addAction(self.action_rename)
        # Delete
        self.action_delete = QtWidgets.QAction(_('&Delete'), self)
        self.action_delete.setShortcut(QtGui.QKeySequence.Delete)
        self.action_delete.setIcon(icons.icon(
            'edit-delete', ':/pyqode-icons/rc/edit-delete.png', 'fa.remove'))
        self.action_delete.triggered.connect(self._on_delete_triggered)
        self.addAction(self.action_delete)
        self.addSeparator()

        text = 'Show in %s' % self.get_file_explorer_name()
        action = self.action_show_in_explorer = self.addAction(text)
        action.setIcon(QtGui.QIcon.fromTheme('system-file-manager'))
        action.triggered.connect(self._on_show_in_explorer_triggered)
        self._action_show_in_explorer = action

    def update_show_in_explorer_action(self):
        self.action_show_in_explorer.setText(
            _('Show in %s') % self.get_file_explorer_name())

    def get_new_user_actions(self):
        """
        Returns user actions for "new" sub-menu.

        Example::

            def get_new_user_actions(self):
                actions = []
                action_python_package = QtWidgets.QAction(
                    '&Python package', self)
                action_python_package.triggered.connect(
                    self._on_create_python_package_triggered)
                actions.append(action_python_package)
                return actions

        """
        return []

    def _on_copy_triggered(self):
        self.tree_view.helper.copy_to_clipboard()

    def _on_cut_triggered(self):
        self.tree_view.helper.copy_to_clipboard(copy=False)

    def _on_paste_triggered(self):
        self.tree_view.helper.paste_from_clipboard()

    def _on_delete_triggered(self):
        self.tree_view.helper.delete()

    def _on_copy_path_triggered(self):
        self.tree_view.helper.copy_path_to_clipboard()

    def _on_rename_triggered(self):
        self.tree_view.helper.rename()

    def _on_create_directory_triggered(self):
        self.tree_view.helper.create_directory()

    def _on_create_file_triggered(self):
        self.tree_view.helper.create_file()

    @classmethod
    def get_linux_file_explorer(cls):
        if cls._explorer is None:
            try:
                output = subprocess.check_output(
                    ['xdg-mime', 'query', 'default', 'inode/directory']).decode()
            except subprocess.CalledProcessError:
                output = ''
            if output:
                explorer = output.splitlines()[0].replace(
                    '.desktop', '').replace('-folder-handler', '').split(
                        '.')[-1].lower()
                FileSystemContextMenu._explorer = explorer
                return explorer
            return ''
        else:
            return cls._explorer

    @classmethod
    def get_file_explorer_name(cls):
        system = platform.system()
        if system == 'Darwin':
            pgm = 'finder'
        elif system == 'Windows':
            pgm = 'explorer'
        else:
            pgm = cls.get_file_explorer_command().split(' ')[0]
            if os.path.isabs(pgm):
                pgm = os.path.split(pgm)[1]
        return pgm.capitalize()

    def _on_show_in_explorer_triggered(self):
        path = self.tree_view.helper.get_current_path()
        self.show_in_explorer(path, self.tree_view)

    @classmethod
    def get_file_explorer_command(cls):
        if cls._command is None:
            system = platform.system()
            if system == 'Linux':
                explorer = cls.get_linux_file_explorer()
                if explorer in ['nautilus', 'dolphin']:
                    explorer_cmd = '%s --select %s' % (explorer, '%s')
                else:
                    explorer_cmd = '%s %s' % (explorer, '%s')
            elif system == 'Windows':
                explorer_cmd = 'explorer /select,%s'
            elif system == 'Darwin':
                explorer_cmd = 'open -R %s'
            cls._command = explorer_cmd
            return explorer_cmd
        else:
            return cls._command

    @classmethod
    def set_file_explorer_command(cls, command):
        pgm = command.split(' ')[0]
        if os.path.isabs(pgm):
            pgm = os.path.split(pgm)[1]
        cls._explorer = pgm
        cls._command = command

    @classmethod
    def show_in_explorer(cls, path, parent):
        try:
            cmd = cls.get_file_explorer_command() % os.path.normpath(path)
            _logger().info('show file in explorer: %s' % cmd)
            args = cmd.split(' ')
            subprocess.Popen(args)
        except Exception as e:
            QtWidgets.QMessageBox.warning(
                parent, _('Open in explorer'),
                _('Failed to open file in explorer.\n\n%s') % str(e))
