# -*- coding: utf-8 -*-
"""
Copyright (C) 2011 Oliver Tengler

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

import os
from typing import List, Tuple, Optional, cast
from enum import IntEnum
from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal, QPoint, QUrl, QModelIndex, QSettings
from PyQt5.QtGui import QFont, QDesktopServices, QShowEvent, QFocusEvent
from PyQt5.QtWidgets import QFrame, QWidget, QApplication, QMenu, QMessageBox, QFileDialog, QHBoxLayout, QSpacerItem, QSizePolicy
from tools import AsynchronousTask
from dialogs.UserHintDialog import showUserHint, ButtonType
from dialogs.RegExTesterDlg import RegExTesterDlg
from dialogs import StackTraceMessageBox
import PathVisualizerDelegate
from fulltextindex import FullTextIndex
from fulltextindex import Query
from fulltextindex.IndexConfiguration import IndexConfiguration, IndexMode
import SearchAsync
import CustomContextMenu
import AppConfig
from StringListModel import StringListModel
from Ui_SearchPage import Ui_SearchPage

userHintUseWildcards = """
<p align='justify'>The search matches words exactly as entered. In order to match words with unknown parts use the asterisk as wildcard.
E.g. <b>part*</b> matches also <b>partial</b>. See the help for more information about the search syntax.</p>
"""

userHintContentNotIndexed = """
<p align='justify'>The file content is not indexed. Try indexing the content if the search performance is not good enough.</p>
"""

userHintFileNameNotIndexed = """
<p align='justify'>The file names are not indexed. Try indexing file names if the search performance is not good enough.</p>
"""

def getCustomScriptsFromDisk() -> List[str]:
    return [s for s in os.listdir("scripts") if os.path.splitext(s)[1].lower() == ".script"]

SearchParams = Tuple[str, str, str, bool]

class SearchType(IntEnum):
    SearchContent = 1
    SearchName = 2

class SearchPage (QWidget):
    # Triggered when a new search tab is requested which should be opened using a given search string
    # First parameter is the search string, the second the display name of the search configuration (IndexConfiguration)
    newSearchRequested = pyqtSignal(str, str)
    # Triggered when a search has finished
    searchFinished = pyqtSignal(QWidget, str)
    # Triggered whenever the view becomes visible and whenever the current file changes
    documentShown = pyqtSignal(str)

    def __init__ (self, parent: QWidget) -> None:
        super ().__init__(parent)
        self.ui = Ui_SearchPage()
        self.ui.setupUi(self)
        self.ui.frameSearch.setProperty("shadeBackground", True) # fill background with gradient as defined in style sheet
        self.ui.frameResult.setProperty("shadeBackground", True) # fill background with gradient as defined in style sheet
        self.ui.listView.setItemDelegate(PathVisualizerDelegate.PathVisualizerDelegate(self.ui.listView))
        self.ui.listView.activated.connect(self.fileSelected)
        self.ui.listView.doubleClicked.connect(self.openFileWithSystem)
        self.ui.listView.customContextMenuRequested.connect(self.contextMenuRequested)
        self.ui.listView.clicked.connect(self.fileSelected)
        self.ui.comboSearch.lineEdit().returnPressed.connect(self.performSearch)
        self.ui.comboFolderFilter.lineEdit().returnPressed.connect(self.performSearch)
        self.ui.comboExtensionFilter.lineEdit().returnPressed.connect(self.performSearch)
        self.ui.sourceViewer.selectionFinishedWithKeyboardModifier.connect(self.newSearchBasedOnSelection)
        self.ui.sourceViewer.noPreviousMatch.connect(self.previousFile)
        self.ui.sourceViewer.noNextMatch.connect(self.nextFile)
        self.ui.matchesOverview.selectionFinishedWithKeyboardModifier.connect(self.newSearchBasedOnSelection)
        self.ui.buttonRegEx.clicked.connect(self.showRegExTester)
        self.ui.comboLocation.currentIndexChanged[str].connect(self.currentLocationChanged) # pylint: disable=unsubscriptable-object
        self.ui.buttonSwitchView.clicked.connect(self.switchView)
        self.ui.buttonSearch.clicked.connect(self.performSearch)
        self.ui.buttonLockResultSet.clicked.connect(self.lockResultSet)
        self.ui.buttonInfo.clicked.connect(self.performanceInfo)
        self.ui.buttonExport.clicked.connect(self.exportMatches)
        self.ui.buttonCustomScripts.clicked.connect(self.execCustomScripts)
        self.ui.buttonChangeSearchType.clicked.connect(self.changeSearchTypeMenu)

        self.ui.splitter.setSizes((1, 2)) # distribute splitter space 1:2

        self.perfReport: Optional[FullTextIndex.PerformanceReport] = None
        self.searchType: SearchType = SearchType.SearchContent
        self.searchLocationList: List[IndexConfiguration] = []
        self.currentConfigName = self.__chooseInitialLocation ()
        self.unavailableConfigName: str = ""
        self.commonKeywordMap = self.__loadCommonKeywordMap()
        self.matches: FullTextIndex.SearchResult = []
        self.sourceFont: QFont = None
        self.lockedResultSet: Optional[FullTextIndex.SearchResult] = None # matches are filtered with this set
        # Hide the custom scripts button if there are no custom scripts on disk
        if not getCustomScriptsFromDisk():
            self.ui.buttonCustomScripts.hide()
        # Hide the performance info button if showPerformanceButton is false
        if not AppConfig.appConfig().showPerformanceButton:
            self.ui.buttonInfo.hide()

        # Move some elements of the search bar to a second row if the screen width is too small. This avoid
        # clipping errors if the widget has to paint below minimum size.
        screenGeometry = QApplication.desktop().screenGeometry()
        if screenGeometry.width() < 1200:
            self.__layoutForLowScreenWidth()

    def showEvent(self, _: QShowEvent) -> None:
        self.documentShown.emit(self.ui.sourceViewer.currentFile)

    @pyqtSlot()
    def changeSearchTypeMenu(self) -> None:
        self.ui.buttonChangeSearchType.setChecked(True)
        menu = QMenu()
        menu.setMinimumWidth(self.ui.buttonChangeSearchType.x() + self.ui.buttonChangeSearchType.width() - self.ui.buttonSearch.x())
        actions = []
        actions.append(menu.addAction("Find content", lambda: self.setSearchType(SearchType.SearchContent)))
        actions.append(menu.addAction("Find name", lambda: self.setSearchType(SearchType.SearchName)))
        pos = self.mapToGlobal(self.ui.widgetSearch.pos())
        pos += QPoint(0, self.ui.buttonSearch.height())
        menu.exec(pos)
        self.ui.buttonChangeSearchType.setChecked(False)

    def setSearchType(self, searchType: SearchType) -> None:
        if self.searchType == searchType:
            return

        self.searchType = searchType
        self.ui.buttonCustomScripts.setEnabled(self.searchType == SearchType.SearchContent)
        self.ui.buttonSwitchView.setEnabled(self.searchType == SearchType.SearchContent)
        if self.searchType == SearchType.SearchName:
            self.switchView(False)
            self.ui.buttonSwitchView.setChecked(False)
            self.ui.buttonSearch.setText("Find name")
        else:
            self.ui.buttonSearch.setText("Find content")

    # Return the display name of the initial config. This is either the configured default location or if there is no default location
    # the last used location.
    def __chooseInitialLocation (self) -> str:
        configName = cast(str,AppConfig.appConfig().defaultLocation) # Display name of current config
        if not configName:
            configName = cast(str,AppConfig.lastUsedConfigName())
        return configName

    def __loadCommonKeywordMap(self) -> FullTextIndex.CommonKeywordMap:
        try:
            return FullTextIndex.buildMapFromCommonKeywordFile (AppConfig.appConfig().commonKeywords)
        except:
            return {}

    def focusInEvent (self, _: QFocusEvent) -> None:
        self.ui.comboSearch.setFocus(Qt.ActiveWindowFocusReason)

    @pyqtSlot(bool)
    def switchView(self, bChecked: bool) -> None:
        if bChecked:
            self.ui.stackedWidget.setCurrentIndex(1)
            self.ui.matchesOverview.activate()
        else:
            self.ui.stackedWidget.setCurrentIndex(0)

    def __updateSourceFont (self) -> QFont:
        if not self.sourceFont:
            self.sourceFont = QFont()

        config = AppConfig.appConfig().SourceViewer

        # Apply font and tab changes (if any)
        if self.sourceFont.family().lower() != config.FontFamily.lower() or self.sourceFont.pointSize() != config.FontSize:
            self.sourceFont.setFamily(config.FontFamily)
            self.sourceFont.setPointSize(config.FontSize)

        return self.sourceFont

    @pyqtSlot(list)
    def reloadConfig (self, searchLocationList: List[IndexConfiguration]) -> None:
        # updateSearchLocationList rebuilds the list which modifies self.currentConfigName so the current config must be preserved
        backupCurrentConfigName = self.currentConfigName
        self.__updateSearchLocationList (searchLocationList)
        if self.unavailableConfigName and self.setCurrentSearchLocation (self.unavailableConfigName):
            # Successfully switched backed to previous config
            self.unavailableConfigName = ""
        elif not self.setCurrentSearchLocation (backupCurrentConfigName):
            # The config is no longer available. This happens most probably during an index update. If the config becomes available later
            # we can switch back to it.
            self.unavailableConfigName = backupCurrentConfigName
        self.ui.sourceViewer.reloadConfig(self.__updateSourceFont())
        self.ui.matchesOverview.reloadConfig(self.__updateSourceFont())

    def __updateSearchLocationList(self,  searchLocationList: List[IndexConfiguration]) -> None:
        self.searchLocationList = searchLocationList
        self.ui.comboLocation.clear()
        if len(self.searchLocationList) <=1:
            self.ui.comboLocation.hide()
            self.ui.labelLocation.hide()
        else:
            self.ui.comboLocation.show()
            self.ui.labelLocation.show()
        for config in self.searchLocationList:
            self.ui.comboLocation.addItem(config.displayName(), config)

    def setCurrentSearchLocation(self, searchLocationName: str) -> bool:
        foundLocation = False
        configName = ""
        for i, config in enumerate (self.searchLocationList):
            if searchLocationName == config.displayName():
                self.ui.comboLocation.setCurrentIndex(i)
                foundLocation=True
                configName=searchLocationName

        # Nothing found, select first one or nothing if the list is empty
        if not foundLocation:
            if self.searchLocationList:
                self.ui.comboLocation.setCurrentIndex (0)
                configName = self.searchLocationList[0].displayName()
            else:
                self.ui.comboLocation.setCurrentIndex(-1)
                configName = ""

        self.currentConfigName = configName
        self.__restoreSearchTerms()

        return foundLocation

    @pyqtSlot(str)
    def currentLocationChanged(self, currentConfigName: str) -> None:
        self.currentConfigName = currentConfigName
        self.__restoreSearchTerms()

    @pyqtSlot(QModelIndex)
    def fileSelected (self,  index: QModelIndex) -> None:
        model = self.ui.listView.model()
        if model.getSelectedFileIndex() != -1:
            model.setEditorState(model.getSelectedFileIndex(), self.ui.sourceViewer.saveEditorState())
        model.setSelectedFileIndex (index.row())
        name = index.data(Qt.UserRole)
        self.showFile (name)
        self.ui.matchesOverview.scrollToFile(index.row())
        editorState = self.ui.listView.model().getEditorState(index.row())
        if editorState:
            self.ui.sourceViewer.restoreEditorState(editorState)

    def showFile (self, name: str) -> None:
        if self.ui.sourceViewer.currentFile != name:
            self.ui.sourceViewer.showFile(name)
            self.documentShown.emit(name)

    @pyqtSlot()
    def nextFile (self) -> None:
        self.__changeSelectedFile (1)

    @pyqtSlot()
    def previousFile (self) -> None:
        self.__changeSelectedFile (-1)

    def __changeSelectedFile (self, increment: int) -> None:
        index = self.ui.listView.currentIndex()
        if index.isValid():
            nextIndex = self.ui.listView.model().index(index.row()+increment, 0)
            if nextIndex.isValid():
                self.ui.listView.setCurrentIndex(nextIndex)
                self.ui.listView.activated.emit(nextIndex)

    @pyqtSlot(str, int)
    def newSearchBasedOnSelection (self, text: str, modifiers: int) -> None:
        if modifiers & Qt.ControlModifier:
            if modifiers & Qt.ShiftModifier:
                # Search in the same search page
                self.searchForText(text)
            else:
                # Search in a new tab
                self.newSearchRequested.emit(text,  self.ui.comboLocation.currentText())

    def getSearchParameterFromUI (self) -> SearchParams:
        strSearch = self.ui.comboSearch.currentText().strip()
        strFolderFilter = self.ui.comboFolderFilter.currentText().strip()
        strExtensionFilter = self.ui.comboExtensionFilter.currentText().strip()
        bCaseSensitive = self.ui.checkCaseSensitive.checkState() == Qt.Checked
        return (strSearch, strFolderFilter,  strExtensionFilter,  bCaseSensitive)

    def __currentIndexConf(self) -> IndexConfiguration:
        i = self.ui.comboLocation.currentIndex()
        config: IndexConfiguration = self.ui.comboLocation.model().index(i, 0).data(Qt.UserRole)
        return config

    # Returns the search parameters from the UI and the current search configuration (IndexConfiguration) object
    def __prepareSearch (self) -> Tuple[SearchParams, IndexConfiguration]:
        self.__updateSearchResult(SearchAsync.ResultSet()) # clear current results
        indexConf = self.__currentIndexConf()
        params = self.getSearchParameterFromUI()
        return (params, indexConf)

    @pyqtSlot()
    def execCustomScripts (self) -> None:
        scripts = getCustomScriptsFromDisk()
        menu = QMenu()
        actions = []
        for script in scripts:
            actions.append(menu.addAction(os.path.splitext(script)[0]))
        pos = self.mapToGlobal(self.ui.buttonCustomScripts.pos())
        pos += QPoint(0, self.ui.buttonCustomScripts.height())
        result = menu.exec(pos)
        if not result:
            return

        try:
            script = scripts[actions.index(result)]
        except ValueError:
            return

        params, indexConf = self.__prepareSearch ()
        if not indexConf:
            return

        try:
            result = SearchAsync.customSearch (self, script, params, indexConf,  self.commonKeywordMap)
        except:
            self.reportCustomSearchFailed ()
        else:
            self.__updateSearchResult(result)

    def searchForText (self,  text: str) -> None:
        self.ui.comboSearch.setEditText(text)
        self.ui.comboSearch.insertItem(0, text)
        self.performSearch()

    @pyqtSlot()
    def performSearch (self) -> None:
        params, indexConf = self.__prepareSearch ()
        if not indexConf:
            return

        AppConfig.setLastUsedConfigName(indexConf.displayName())

        try:
            if self.searchType == SearchType.SearchContent:
                result = SearchAsync.searchContent (self, params, indexConf,  self.commonKeywordMap)
            else:
                result = SearchAsync.searchFileName (self, params, indexConf)
        except Query.QueryError as error:
            self.reportQueryError(error)
        except:
            self.reportFailedSearch(indexConf)
        else:
            self.__updateSearchResult(result)
            self.__rememberSearchTerms()
            text = self.tr(userHintUseWildcards)
            if self.searchType == SearchType.SearchContent:
                showUserHint (self, "useWildcards",  self.tr("Try using wildcards"), text,  ButtonType.OK)
            
            if indexConf.indexUpdateMode != IndexMode.NoIndexWanted:
                if self.searchType == SearchType.SearchContent and not indexConf.isContentIndexed():
                    text = self.tr(userHintContentNotIndexed)
                    showUserHint (self, "contentSearchNotIndexed_" + indexConf.displayName(), self.tr("This search can be faster"), text, ButtonType.OK)
                if self.searchType == SearchType.SearchName and not indexConf.isFileNameIndexed():
                    text = self.tr(userHintFileNameNotIndexed)
                    showUserHint (self, "fileNameSearchNotIndexed_" + indexConf.displayName(), self.tr("This search can be faster"), text, ButtonType.OK)

    def __updateSearchResult (self, result: SearchAsync.ResultSet) -> None:
        if result.label:
            self.searchFinished.emit(self, result.label)
        self.perfReport = result.perfReport
        # Filter results if we currently have a locked result set
        if self.lockedResultSet:
            matches = FullTextIndex.intersectSortedLists (self.lockedResultSet, result.matches)
        else:
            matches = result.matches
        self.matches = matches
        self.ui.sourceViewer.setSearchData (result.searchData)
        self.ui.matchesOverview.setSearchResult(self.matches, result.searchData)
        self.ui.labelMatches.setText("%u " % (len(matches), ) + self.tr("matches"))
        model = StringListModel(matches)
        sizeHint = self.ui.listView.itemDelegate().computeSizeHint(matches,  model.cutLeft)
        model.setSizeHint(sizeHint)
        self.ui.listView.setModel(model)
        # Activate first match if enabled in config
        if AppConfig.appConfig().activateFirstMatch:
            if model.rowCount() > 0:
                index = self.ui.listView.model().index(0, 0)
                if index.isValid():
                    self.ui.listView.setCurrentIndex(index)
                    self.ui.listView.activated.emit(index)

    @pyqtSlot(bool)
    def lockResultSet (self,  bChecked: bool) -> None:
        if bChecked:
            self.lockedResultSet = self.matches[:] # copy the matches, a reference is not enough
        else:
            self.lockedResultSet = None

    @pyqtSlot(QModelIndex)
    def openFileWithSystem(self, index: QModelIndex) -> None:
        name = index.data(Qt.UserRole)
        url = QUrl.fromLocalFile (name)
        QDesktopServices.openUrl (url)

    @pyqtSlot()
    def performanceInfo (self) -> None:
        if not self.perfReport:
            return
        QMessageBox.information(self, self.tr("Performance info"), str(self.perfReport),
                                QMessageBox.StandardButtons(QMessageBox.Ok), QMessageBox.Ok)

    @pyqtSlot()
    def exportMatches(self) -> None:
        model = self.ui.listView.model()
        if not model or model.rowCount()==0:
            return
        result = ""
        for row in range(model.rowCount()):
            index = model.index(row, 0)
            if result:
                result += os.linesep
            result += model.data(index, Qt.UserRole)

        exportFile = QFileDialog.getSaveFileName(
            self,
            self.tr("Export matches"),
            self.tr("export.txt"),
            self.tr("txt"))[0] # tuple returned, selection and used filter

        if not exportFile:
            return

        with open (exportFile, "w",  -1,  "utf_8_sig") as output:
            output.write(result)

    @pyqtSlot(QPoint)
    def contextMenuRequested(self, pos: QPoint) -> None:
        files = self.__getSelectedFiles()
        if not files:
            return
        fullpath = files[0]
        name = os.path.split(fullpath)[1]
        menu = QMenu()
        menu.addAction(self.tr("Copy &full path"),  lambda: self.__copyFullPaths(files))
        if len(files)==1:
            menu.addAction(self.tr("Copy &path of containing folder"),  lambda: self.__copyPathOfContainingFolder(fullpath))
        menu.addAction(self.tr("Copy file &name"),  lambda: self.__copyFileNames(files))
        if len(files)==1:
            menu.addAction(self.tr("Open containing f&older"),  lambda: self.__browseToFolder(fullpath))
            menu.addAction(self.tr("Search for") + " '" + name + "'",  lambda: self.__searchForFileName(name))

        entries = CustomContextMenu.customMenuEntries (AppConfig.appConfig())
        filePairSelected = len(self.__getSelectedFiles()) == 2
        for entry in entries:
            try:
                entry.executionFailed.disconnect() # will raise error if there are no connections
            except:
                pass
            entry.executionFailed.connect (self.reportCustomContextMenuFailed)
            if (entry.filePair and filePairSelected) or not entry.filePair:
                # The default lambda argument is used to preserve the value of entry for each lambda. Otherwise all lambdas would call the last entry.execute
                # See http://stackoverflow.com/questions/2295290/what-do-lambda-function-closures-capture-in-python
                menu.addAction(entry.title,  lambda entry=entry: AsynchronousTask.execute (self, entry.execute,  self.__getSelectedFiles()))

        menu.exec(self.ui.listView.mapToGlobal(pos))

    @pyqtSlot()
    def showRegExTester(self) -> None:
        tester = RegExTesterDlg(self)
        tester.setAttribute(Qt.WA_DeleteOnClose)
        tester.show()

    def __copyFullPaths(self,  names: List[str]) -> None:
        clipboard = QApplication.clipboard()
        clipboard.setText(os.linesep.join(names))

    def __copyPathOfContainingFolder(self,  name: str) -> None:
        clipboard = QApplication.clipboard()
        clipboard.setText(os.path.split(name)[0])

    def __copyFileNames(self,  names: List[str]) -> None:
        clipboard = QApplication.clipboard()
        text = os.linesep.join(os.path.split(name)[1] for name in names)
        clipboard.setText(text)

    def __browseToFolder (self,  name: str) -> None:
        if os.name != "nt":
            url = QUrl.fromLocalFile (os.path.split(name)[0])
            QDesktopServices.openUrl (url)
        else:
            import subprocess
            subprocess.Popen (["explorer.exe", "/select,", name])

    def __searchForFileName (self,  name: str) -> None:
        self.newSearchRequested.emit(name,  self.ui.comboLocation.currentText())

    def __getSelectedFiles (self) -> List[str]:
        filenames = []
        indexes = self.ui.listView.selectedIndexes ()
        for index in indexes:
            if index.isValid():
                filenames.append (index.data(Qt.UserRole))
        return filenames

    def __layoutForLowScreenWidth (self) -> None:
        self.ui.frameSearch2 = QFrame(self) # type: ignore
        self.ui.frameSearch2.setProperty("shadeBackground", True) # type: ignore
        self.ui.horizontalLayout2 = QHBoxLayout(self.ui.frameSearch2) # type: ignore
        self.ui.horizontalLayout2.setContentsMargins(22, 0, 22, -1) # type: ignore
        layout = self.ui.horizontalLayout2 # type: ignore
        layout.removeWidget(self.ui.labelFolderFilter)
        layout.removeWidget(self.ui.comboFolderFilter)
        layout.removeWidget(self.ui.labelExtensionFilter)
        layout.removeWidget(self.ui.comboExtensionFilter)
        layout.removeWidget(self.ui.checkCaseSensitive)
        layout.addWidget(self.ui.labelFolderFilter)
        layout.addWidget(self.ui.comboFolderFilter)
        layout.addWidget(self.ui.labelExtensionFilter)
        layout.addWidget(self.ui.comboExtensionFilter)
        layout.addWidget(self.ui.checkCaseSensitive)
        layout.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
        self.layout().insertWidget(1, self.ui.frameSearch2) # type: ignore

    def __restoreSearchTerms(self) -> None:
        currentText = self.ui.comboSearch.currentText()
        self.ui.comboSearch.clear()
        if self.currentConfigName:
            settings = QSettings(AppConfig.appCompany, AppConfig.appName)
            key = "SearchTerms_"+self.currentConfigName
            if settings.value(key):
                strList = settings.value(key)
                self.ui.comboSearch.addItems(strList)
        self.ui.comboSearch.setEditText(currentText)

    def __rememberSearchTerms(self) -> None:
        model = self.ui.comboSearch.model()
        if not model or model.rowCount()==0:
            return
        terms=[]
        for row in range(min(20,model.rowCount())):
            index = model.index(row, 0)
            terms.append(model.data(index, Qt.DisplayRole))
        settings = QSettings(AppConfig.appCompany, AppConfig.appName)
        settings.setValue("SearchTerms_"+self.currentConfigName, terms)

    @pyqtSlot(CustomContextMenu.ContextMenuError)
    def reportCustomContextMenuFailed (self, contextMenuError: CustomContextMenu.ContextMenuError) -> None:
        if not contextMenuError.exception:
            QMessageBox.warning(self,
                                self.tr("Custom context menu failed"),
                                self.tr("Failed to start '") + contextMenuError.program + self.tr("' for:\n") + "\n".join(contextMenuError.failedFiles),
                                QMessageBox.StandardButtons(QMessageBox.Ok))
        else:
            QMessageBox.warning(self,
                                self.tr("Custom context menu failed"),
                                self.tr("The custom context menu script '") + contextMenuError.program + self.tr("' failed to execute:\n") + contextMenuError.exception,
                                QMessageBox.StandardButtons(QMessageBox.Ok))

    def reportQueryError(self,  error: Query.QueryError) -> None:
        StackTraceMessageBox.show(self,
                                  self.tr("Search not possible"),
                                  str(error))

    def reportFailedSearch(self, indexConf: IndexConfiguration) -> None:
        """Show the user possible reason why the search threw an exception."""
        if indexConf.generatesIndex():
            StackTraceMessageBox.show(self,
                                      self.tr("Search failed"),
                                      self.tr("""Maybe the index has not been generated yet or is not accessible?"""))
        else:
            StackTraceMessageBox.show(self,
                                      self.tr("Search failed"),
                                      self.tr("""Please check that the search location exists and is accessible."""))

    def reportCustomSearchFailed (self) -> None:
        StackTraceMessageBox.show(self,
                                  self.tr("Custom search failed"),
                                  self.tr("Custom search scripts are written in Python. Click on 'Show details' to display the stack trace."))