"""
novelWriter – Config Class
==========================

File History:
Created: 2018-09-22 [0.0.1]  Config
Created: 2022-11-09 [2.0rc2] RecentProjects

This file is a part of novelWriter
Copyright 2018–2023, Veronica Berglyd Olsen

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU 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
General Public License for more details.

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

import sys
import json
import logging

from time import time
from pathlib import Path

from PyQt5.QtGui import QFontDatabase
from PyQt5.QtCore import (
    PYQT_VERSION, PYQT_VERSION_STR, QT_VERSION, QT_VERSION_STR, QLibraryInfo,
    QLocale, QStandardPaths, QSysInfo, QTranslator
)
from PyQt5.QtWidgets import QApplication

from novelwriter.error import formatException, logException
from novelwriter.common import NWConfigParser, checkInt, checkPath, formatTimeStamp
from novelwriter.constants import nwFiles, nwUnicode

logger = logging.getLogger(__name__)


class Config:

    LANG_NW   = 1
    LANG_PROJ = 2

    def __init__(self) -> None:

        # Initialisation
        # ==============

        # Set Application Variables
        self.appName   = "novelWriter"
        self.appHandle = "novelwriter"

        # Set Paths
        confRoot = Path(QStandardPaths.writableLocation(QStandardPaths.ConfigLocation))
        dataRoot = Path(QStandardPaths.writableLocation(QStandardPaths.AppDataLocation))

        self._confPath = confRoot.absolute() / self.appHandle  # The user config location
        self._dataPath = dataRoot.absolute() / self.appHandle  # The user data location
        self._homePath = Path.home().absolute()  # The user's home directory
        self._backPath = self._homePath / "Backups"

        self._appPath = Path(__file__).parent.absolute()
        self._appRoot = self._appPath.parent
        if self._appRoot.is_file():
            # novelWriter is packaged as a single file
            self._appRoot = self._appRoot.parent
            self._appPath = self._appRoot

        # Runtime Settings and Variables
        self._hasError = False  # True if the config class encountered an error
        self._errData  = []     # List of error messages

        # Localisation
        # Note that these paths must be strings
        self._qLocale    = QLocale.system()
        self._qtTrans    = {}
        self._qtLangPath = QLibraryInfo.location(QLibraryInfo.TranslationsPath)
        self._nwLangPath = str(self._appPath / "assets" / "i18n")

        # PDF Manual
        pdfDocs = self._appPath / "assets" / "manual.pdf"
        self.pdfDocs = pdfDocs if pdfDocs.is_file() else None

        # User Settings
        # =============

        self._recentObj = RecentProjects(self)

        # General GUI Settings
        self.guiLocale   = self._qLocale.name()
        self.guiTheme    = "default"        # GUI theme
        self.guiSyntax   = "default_light"  # Syntax theme
        self.guiFont     = ""               # Defaults to system default font in theme class
        self.guiFontSize = 11               # Is overridden if system default is loaded
        self.guiScale    = 1.0              # Set automatically by Theme class
        self.hideVScroll = False            # Hide vertical scroll bars on main widgets
        self.hideHScroll = False            # Hide horizontal scroll bars on main widgets
        self.lastNotes   = "0x0"            # The latest release notes that have been shown

        # Size Settings
        self._mainWinSize  = [1200, 650]     # Last size of the main GUI window
        self._prefsWinSize = [700, 615]      # Last size of the Preferences dialog
        self._projLoadCols = [280, 60, 160]  # Last columns widths of the Project Load dialog
        self._mainPanePos  = [300, 800]      # Last position of the main window splitter
        self._viewPanePos  = [500, 150]      # Last position of the document viewer splitter
        self._outlnPanePos = [500, 150]      # Last position of the outline panel splitter

        # Project Settings
        self.autoSaveProj    = 60     # Interval for auto-saving project, in seconds
        self.autoSaveDoc     = 30     # Interval for auto-saving document, in seconds
        self.emphLabels      = True   # Add emphasis to H1 and H2 item labels
        self.backupOnClose   = False  # Flag for running automatic backups
        self.askBeforeBackup = True   # Flag for asking before running automatic backup

        # Text Editor Settings
        self.textFont        = ""     # Editor font
        self.textSize        = 12     # Editor font size
        self.textWidth       = 700    # Editor text width
        self.textMargin      = 40     # Editor/viewer text margin
        self.tabWidth        = 40     # Editor tabulator width

        self.focusWidth      = 800    # Focus Mode text width
        self.hideFocusFooter = False  # Hide document footer in Focus Mode
        self.showFullPath    = True   # Show full document path in editor header
        self.autoSelect      = True   # Auto-select word when applying format with no selection

        self.doJustify       = False  # Justify text
        self.showTabsNSpaces = False  # Show tabs and spaces in editor
        self.showLineEndings = False  # Show line endings in editor
        self.showMultiSpaces = True   # Highlight multiple spaces in the text

        self.doReplace       = True   # Enable auto-replace as you type
        self.doReplaceSQuote = True   # Smart single quotes
        self.doReplaceDQuote = True   # Smart double quotes
        self.doReplaceDash   = True   # Replace multiple hyphens with dashes
        self.doReplaceDots   = True   # Replace three dots with ellipsis

        self.scrollPastEnd   = 25     # Number of lines to scroll past end of document
        self.autoScroll      = False  # Typewriter-like scrolling
        self.autoScrollPos   = 30     # Start point for typewriter-like scrolling

        self.wordCountTimer  = 5.0    # Interval for word count update in seconds
        self.bigDocLimit     = 800    # Size threshold for heavy editor features in kilobytes
        self.incNotesWCount  = True   # The status bar word count includes notes

        self.highlightQuotes = True   # Highlight text in quotes
        self.allowOpenSQuote = False  # Allow open-ended single quotes
        self.allowOpenDQuote = True   # Allow open-ended double quotes
        self.highlightEmph   = True   # Add colour to text emphasis

        self.stopWhenIdle    = True   # Stop the status bar clock when the user is idle
        self.userIdleTime    = 300    # Time of inactivity to consider user idle

        # User-Selected Symbol Settings
        self.fmtApostrophe   = nwUnicode.U_RSQUO
        self.fmtSQuoteOpen   = nwUnicode.U_LSQUO
        self.fmtSQuoteClose  = nwUnicode.U_RSQUO
        self.fmtDQuoteOpen   = nwUnicode.U_LDQUO
        self.fmtDQuoteClose  = nwUnicode.U_RDQUO
        self.fmtPadBefore    = ""
        self.fmtPadAfter     = ""
        self.fmtPadThin      = False

        # User Paths
        self._lastPath   = self._homePath  # The user's last used path
        self._backupPath = self._backPath  # Backup path to use, can be none

        # Spell Checking Settings
        self.spellLanguage = "en"

        # State
        self.showRefPanel = True  # The reference panel for the viewer is visible
        self.viewComments = True  # Comments are shown in the viewer
        self.viewSynopsis = True  # Synopsis is shown in the viewer

        # Search Bar Switches
        self.searchCase     = False
        self.searchWord     = False
        self.searchRegEx    = False
        self.searchLoop     = False
        self.searchNextFile = False
        self.searchMatchCap = False

        # System and App Information
        # ==========================

        # Check Qt5 Versions
        self.verQtString   = QT_VERSION_STR
        self.verQtValue    = QT_VERSION
        self.verPyQtString = PYQT_VERSION_STR
        self.verPyQtValue  = PYQT_VERSION

        # Check Python Version
        self.verPyString = sys.version.split()[0]

        # Check OS Type
        self.osType    = sys.platform
        self.osLinux   = False
        self.osWindows = False
        self.osDarwin  = False
        self.osUnknown = False
        if self.osType.startswith("linux"):
            self.osLinux = True
        elif self.osType.startswith("darwin"):
            self.osDarwin = True
        elif self.osType.startswith("win32"):
            self.osWindows = True
        elif self.osType.startswith("cygwin"):
            self.osWindows = True
        else:
            self.osUnknown = True

        # Other System Info
        self.hostName  = QSysInfo.machineHostName()
        self.kernelVer = QSysInfo.kernelVersion()

        # Packages
        self.hasEnchant = False  # The pyenchant package

        return

    ##
    #  Properties
    ##

    @property
    def hasError(self) -> bool:
        return self._hasError

    @property
    def recentProjects(self) -> RecentProjects:
        return self._recentObj

    @property
    def mainWinSize(self) -> list[int]:
        return [int(x*self.guiScale) for x in self._mainWinSize]

    @property
    def preferencesWinSize(self) -> list[int]:
        return [int(x*self.guiScale) for x in self._prefsWinSize]

    @property
    def projLoadColWidths(self) -> list[int]:
        return [int(x*self.guiScale) for x in self._projLoadCols]

    @property
    def mainPanePos(self) -> list[int]:
        return [int(x*self.guiScale) for x in self._mainPanePos]

    @property
    def viewPanePos(self) -> list[int]:
        return [int(x*self.guiScale) for x in self._viewPanePos]

    @property
    def outlinePanePos(self) -> list[int]:
        return [int(x*self.guiScale) for x in self._outlnPanePos]

    ##
    #  Getters
    ##

    def getTextWidth(self, focusMode: bool = False) -> int:
        """Get the text with for the correct editor mode."""
        if focusMode:
            return self.pxInt(max(self.focusWidth, 200))
        else:
            return self.pxInt(max(self.textWidth, 200))

    def getTextMargin(self) -> int:
        """Get the scaled text margin."""
        return self.pxInt(max(self.textMargin, 0))

    def getTabWidth(self) -> int:
        """Get the scaled tab width."""
        return self.pxInt(max(self.tabWidth, 0))

    ##
    #  Setters
    ##

    def setMainWinSize(self, width: int, height: int) -> None:
        """Set the size of the main window, but only if the change is
        larger than 5 pixels. The OS window manager will sometimes
        adjust it a bit, and we don't want the main window to shrink or
        grow each time the app is opened.
        """
        width = int(width/self.guiScale)
        height = int(height/self.guiScale)
        if abs(self._mainWinSize[0] - width) > 5:
            self._mainWinSize[0] = width
        if abs(self._mainWinSize[1] - height) > 5:
            self._mainWinSize[1] = height
        return

    def setPreferencesWinSize(self, width: int, height: int) -> None:
        """Set the size of the Preferences dialog window."""
        self._prefsWinSize[0] = int(width/self.guiScale)
        self._prefsWinSize[1] = int(height/self.guiScale)
        return

    def setProjLoadColWidths(self, widths: list[int]) -> None:
        """Set the column widths of the Load Project dialog."""
        self._projLoadCols = [int(x/self.guiScale) for x in widths]
        return

    def setMainPanePos(self, pos: list[int]) -> None:
        """Set the position of the main GUI splitter."""
        self._mainPanePos = [int(x/self.guiScale) for x in pos]
        return

    def setViewPanePos(self, pos: list[int]) -> None:
        """Set the position of the viewer meta data splitter."""
        self._viewPanePos = [int(x/self.guiScale) for x in pos]
        return

    def setOutlinePanePos(self, pos: list[int]) -> None:
        """Set the position of the outline details splitter."""
        self._outlnPanePos = [int(x/self.guiScale) for x in pos]
        return

    def setLastPath(self, path: str | Path) -> None:
        """Set the last used path. Only the folder is saved, so if the
        path is not a folder, the parent of the path is used instead.
        """
        if isinstance(path, (str, Path)):
            path = checkPath(path, self._homePath)
            if not path.is_dir():
                path = path.parent
            if path.is_dir():
                self._lastPath = path
                logger.debug("Last path updated: %s" % self._lastPath)
        return

    def setBackupPath(self, path: Path | str) -> None:
        """Set the current backup path."""
        self._backupPath = checkPath(path, self._backPath)
        return

    def setTextFont(self, family: str | None, pointSize: int = 12) -> None:
        """Set the text font if it exists. If it doesn't, or is None,
        set to default font.
        """
        fontDB = QFontDatabase()
        fontFam = fontDB.families()
        self.textSize = pointSize
        if family is None or family not in fontFam:
            logger.warning("Unknown font '%s'", family)
            if self.osWindows and "Arial" in fontFam:
                self.textFont = "Arial"
            elif self.osDarwin and "Helvetica" in fontFam:
                self.textFont = "Helvetica"
            else:
                self.textFont = fontDB.systemFont(QFontDatabase.GeneralFont).family()
        else:
            self.textFont = family
        return

    ##
    #  Methods
    ##

    def pxInt(self, value: int) -> int:
        """Scale fixed gui sizes by the screen scale factor."""
        return int(value*self.guiScale)

    def rpxInt(self, value: int) -> int:
        """Un-scale fixed gui sizes by the screen scale factor."""
        return int(value/self.guiScale)

    def dataPath(self, target: str | None = None) -> Path:
        """Return a path in the data folder."""
        if isinstance(target, str):
            return self._dataPath / target
        return self._dataPath

    def assetPath(self, target: str | None = None) -> Path:
        """Return a path in the assets folder."""
        if isinstance(target, str):
            return self._appPath / "assets" / target
        return self._appPath / "assets"

    def lastPath(self) -> Path:
        """Return the last path used by the user, but ensure it exists.
        """
        if isinstance(self._lastPath, Path):
            if self._lastPath.is_dir():
                return self._lastPath
        return self._homePath

    def backupPath(self) -> Path:
        """Return the backup path."""
        if isinstance(self._backupPath, Path):
            if self._backupPath.is_dir():
                return self._backupPath
        return self._backPath

    def errorText(self) -> str:
        """Compile and return error messages from the initialisation of
        the Config class, and clear the error buffer.
        """
        errMessage = "<br>".join(self._errData)
        self._hasError = False
        self._errData = []
        return errMessage

    def listLanguages(self, lngSet: int) -> list[tuple[str, str]]:
        """List localisation files in the i18n folder. The default GUI
        language is British English (en_GB).
        """
        if lngSet == self.LANG_NW:
            fPre = "nw_"
            fExt = ".qm"
            langList = {"en_GB": QLocale("en_GB").nativeLanguageName().title()}
        elif lngSet == self.LANG_PROJ:
            fPre = "project_"
            fExt = ".json"
            langList = {"en_GB": QLocale("en_GB").nativeLanguageName().title()}
        else:
            return []

        for qmFile in Path(self._nwLangPath).iterdir():
            qmName = qmFile.name
            if not (qmFile.is_file() and qmName.startswith(fPre) and qmName.endswith(fExt)):
                continue

            qmLang = qmName[len(fPre):-len(fExt)]
            qmName = QLocale(qmLang).nativeLanguageName().title()
            if qmLang and qmName and qmLang != "en_GB":
                langList[qmLang] = qmName

        return sorted(langList.items(), key=lambda x: x[0])

    ##
    #  Config Actions
    ##

    def initConfig(self, confPath: str | Path | None = None,
                   dataPath: str | Path | None = None) -> None:
        """Initialise the config class. The manual setting of confPath
        and dataPath is mainly intended for the test suite.
        """
        logger.debug("Initialising Config ...")
        if isinstance(confPath, (str, Path)):
            logger.info("Setting alternative config path: %s", confPath)
            self._confPath = Path(confPath)
        if isinstance(dataPath, (str, Path)):
            logger.info("Setting alternative data path: %s", dataPath)
            self._dataPath = Path(dataPath)

        logger.debug("Config Path: %s", self._confPath)
        logger.debug("Data Path: %s", self._dataPath)
        logger.debug("App Root: %s", self._appRoot)
        logger.debug("App Path: %s", self._appPath)
        logger.debug("Last Path: %s", self._lastPath)
        logger.debug("PDF Manual: %s", self.pdfDocs)

        # If the config and data folders don't exist, create them
        # This assumes that the os config and data folders exist
        self._confPath.mkdir(exist_ok=True)
        self._dataPath.mkdir(exist_ok=True)

        # Also create the syntax, themes and icons folders if possible
        if self._dataPath.is_dir():
            (self._dataPath / "cache").mkdir(exist_ok=True)
            (self._dataPath / "icons").mkdir(exist_ok=True)
            (self._dataPath / "syntax").mkdir(exist_ok=True)
            (self._dataPath / "themes").mkdir(exist_ok=True)

        # Check if config file exists, and load it. If not, we save defaults
        if (self._confPath / nwFiles.CONF_FILE).is_file():
            self.loadConfig()
        else:
            self.saveConfig()

        self._recentObj.loadCache()
        self._checkOptionalPackages()

        logger.debug("Config instance initialised")

        return

    def initLocalisation(self, nwApp: QApplication) -> None:
        """Initialise the localisation of the GUI."""
        self._qLocale = QLocale(self.guiLocale)
        QLocale.setDefault(self._qLocale)
        self._qtTrans = {}

        langList = [
            (self._qtLangPath, "qtbase"),  # Qt 5.x
            (self._nwLangPath, "nw"),      # novelWriter
        ]
        for lngPath, lngBase in langList:
            for lngCode in self._qLocale.uiLanguages():
                qTrans = QTranslator()
                lngFile = "%s_%s" % (lngBase, lngCode.replace("-", "_"))
                if lngFile not in self._qtTrans:
                    if qTrans.load(lngFile, lngPath):
                        logger.debug("Loaded: %s.qm", lngFile)
                        nwApp.installTranslator(qTrans)
                        self._qtTrans[lngFile] = qTrans

        return

    def loadConfig(self) -> bool:
        """Load preferences from file and replace default settings."""
        logger.debug("Loading config file")

        conf = NWConfigParser()
        cnfPath = self._confPath / nwFiles.CONF_FILE
        try:
            with open(cnfPath, mode="r", encoding="utf-8") as inFile:
                conf.read_file(inFile)
        except Exception as exc:
            logger.error("Could not load config file")
            logException()
            self._hasError = True
            self._errData.append("Could not load config file")
            self._errData.append(formatException(exc))
            return False

        # Main
        sec = "Main"
        self.guiTheme    = conf.rdStr(sec, "theme", self.guiTheme)
        self.guiSyntax   = conf.rdStr(sec, "syntax", self.guiSyntax)
        self.guiFont     = conf.rdStr(sec, "font", self.guiFont)
        self.guiFontSize = conf.rdInt(sec, "fontsize", self.guiFontSize)
        self.guiLocale   = conf.rdStr(sec, "localisation", self.guiLocale)
        self.hideVScroll = conf.rdBool(sec, "hidevscroll", self.hideVScroll)
        self.hideHScroll = conf.rdBool(sec, "hidehscroll", self.hideHScroll)
        self.lastNotes   = conf.rdStr(sec, "lastnotes", self.lastNotes)
        self._lastPath   = conf.rdPath(sec, "lastpath", self._lastPath)

        # Sizes
        sec = "Sizes"
        self._mainWinSize  = conf.rdIntList(sec, "mainwindow", self._mainWinSize)
        self._prefsWinSize = conf.rdIntList(sec, "preferences", self._prefsWinSize)
        self._projLoadCols = conf.rdIntList(sec, "projloadcols", self._projLoadCols)
        self._mainPanePos  = conf.rdIntList(sec, "mainpane", self._mainPanePos)
        self._viewPanePos  = conf.rdIntList(sec, "viewpane", self._viewPanePos)
        self._outlnPanePos = conf.rdIntList(sec, "outlinepane", self._outlnPanePos)

        # Project
        sec = "Project"
        self.autoSaveProj    = conf.rdInt(sec, "autosaveproject", self.autoSaveProj)
        self.autoSaveDoc     = conf.rdInt(sec, "autosavedoc", self.autoSaveDoc)
        self.emphLabels      = conf.rdBool(sec, "emphlabels", self.emphLabels)
        self._backupPath     = conf.rdPath(sec, "backuppath", self._backupPath)
        self.backupOnClose   = conf.rdBool(sec, "backuponclose", self.backupOnClose)
        self.askBeforeBackup = conf.rdBool(sec, "askbeforebackup", self.askBeforeBackup)

        # Editor
        sec = "Editor"
        self.textFont        = conf.rdStr(sec, "textfont", self.textFont)
        self.textSize        = conf.rdInt(sec, "textsize", self.textSize)
        self.textWidth       = conf.rdInt(sec, "width", self.textWidth)
        self.textMargin      = conf.rdInt(sec, "margin", self.textMargin)
        self.tabWidth        = conf.rdInt(sec, "tabwidth", self.tabWidth)
        self.focusWidth      = conf.rdInt(sec, "focuswidth", self.focusWidth)
        self.hideFocusFooter = conf.rdBool(sec, "hidefocusfooter", self.hideFocusFooter)
        self.doJustify       = conf.rdBool(sec, "justify", self.doJustify)
        self.autoSelect      = conf.rdBool(sec, "autoselect", self.autoSelect)
        self.doReplace       = conf.rdBool(sec, "autoreplace", self.doReplace)
        self.doReplaceSQuote = conf.rdBool(sec, "repsquotes", self.doReplaceSQuote)
        self.doReplaceDQuote = conf.rdBool(sec, "repdquotes", self.doReplaceDQuote)
        self.doReplaceDash   = conf.rdBool(sec, "repdash", self.doReplaceDash)
        self.doReplaceDots   = conf.rdBool(sec, "repdots", self.doReplaceDots)
        self.scrollPastEnd   = conf.rdInt(sec, "scrollpastend", self.scrollPastEnd)
        self.autoScroll      = conf.rdBool(sec, "autoscroll", self.autoScroll)
        self.autoScrollPos   = conf.rdInt(sec, "autoscrollpos", self.autoScrollPos)
        self.fmtSQuoteOpen   = conf.rdStr(sec, "fmtsquoteopen", self.fmtSQuoteOpen)
        self.fmtSQuoteClose  = conf.rdStr(sec, "fmtsquoteclose", self.fmtSQuoteClose)
        self.fmtDQuoteOpen   = conf.rdStr(sec, "fmtdquoteopen", self.fmtDQuoteOpen)
        self.fmtDQuoteClose  = conf.rdStr(sec, "fmtdquoteclose", self.fmtDQuoteClose)
        self.fmtPadBefore    = conf.rdStr(sec, "fmtpadbefore", self.fmtPadBefore)
        self.fmtPadAfter     = conf.rdStr(sec, "fmtpadafter", self.fmtPadAfter)
        self.fmtPadThin      = conf.rdBool(sec, "fmtpadthin", self.fmtPadThin)
        self.spellLanguage   = conf.rdStr(sec, "spellcheck", self.spellLanguage)
        self.showTabsNSpaces = conf.rdBool(sec, "showtabsnspaces", self.showTabsNSpaces)
        self.showLineEndings = conf.rdBool(sec, "showlineendings", self.showLineEndings)
        self.showMultiSpaces = conf.rdBool(sec, "showmultispaces", self.showMultiSpaces)
        self.wordCountTimer  = conf.rdFlt(sec, "wordcounttimer", self.wordCountTimer)
        self.bigDocLimit     = conf.rdInt(sec, "bigdoclimit", self.bigDocLimit)
        self.incNotesWCount  = conf.rdBool(sec, "incnoteswcount", self.incNotesWCount)
        self.showFullPath    = conf.rdBool(sec, "showfullpath", self.showFullPath)
        self.highlightQuotes = conf.rdBool(sec, "highlightquotes", self.highlightQuotes)
        self.allowOpenSQuote = conf.rdBool(sec, "allowopensquote", self.allowOpenSQuote)
        self.allowOpenDQuote = conf.rdBool(sec, "allowopendquote", self.allowOpenDQuote)
        self.highlightEmph   = conf.rdBool(sec, "highlightemph", self.highlightEmph)
        self.stopWhenIdle    = conf.rdBool(sec, "stopwhenidle", self.stopWhenIdle)
        self.userIdleTime    = conf.rdInt(sec, "useridletime", self.userIdleTime)

        # State
        sec = "State"
        self.showRefPanel   = conf.rdBool(sec, "showrefpanel", self.showRefPanel)
        self.viewComments   = conf.rdBool(sec, "viewcomments", self.viewComments)
        self.viewSynopsis   = conf.rdBool(sec, "viewsynopsis", self.viewSynopsis)
        self.searchCase     = conf.rdBool(sec, "searchcase", self.searchCase)
        self.searchWord     = conf.rdBool(sec, "searchword", self.searchWord)
        self.searchRegEx    = conf.rdBool(sec, "searchregex", self.searchRegEx)
        self.searchLoop     = conf.rdBool(sec, "searchloop", self.searchLoop)
        self.searchNextFile = conf.rdBool(sec, "searchnextfile", self.searchNextFile)
        self.searchMatchCap = conf.rdBool(sec, "searchmatchcap", self.searchMatchCap)

        # Deprecated Settings or Locations as of 2.0
        # ToDo: These will be loaded for a few minor releases until the users have converted them
        self.guiFont         = conf.rdStr("Main", "guifont", self.guiFont)
        self.guiFontSize     = conf.rdInt("Main", "guifontsize", self.guiFontSize)
        self.guiLocale       = conf.rdStr("Main", "guilang", self.guiLocale)
        self._backupPath     = conf.rdPath("Backup", "backuppath", self._backupPath)
        self.backupOnClose   = conf.rdBool("Backup", "backuponclose", self.backupOnClose)
        self.askBeforeBackup = conf.rdBool("Backup", "askbeforebackup", self.askBeforeBackup)
        fmtSingleQuotes      = conf.rdStrList(sec, "fmtsinglequote", [])
        fmtDoubleQuotes      = conf.rdStrList(sec, "fmtdoublequote", [])

        if isinstance(fmtSingleQuotes, list) and len(fmtSingleQuotes) == 2:
            self.fmtSQuoteOpen = fmtSingleQuotes[0]
            self.fmtSQuoteClose = fmtSingleQuotes[1]
        if isinstance(fmtDoubleQuotes, list) and len(fmtDoubleQuotes) == 2:
            self.fmtDQuoteOpen = fmtDoubleQuotes[0]
            self.fmtDQuoteClose = fmtDoubleQuotes[1]

        # Check Values
        # ============

        # If we're using straight quotes, disable auto-replace
        if self.fmtSQuoteOpen == self.fmtSQuoteClose == "'" and self.doReplaceSQuote:
            logger.info("Using straight single quotes, so disabling auto-replace")
            self.doReplaceSQuote = False

        if self.fmtDQuoteOpen == self.fmtDQuoteClose == '"' and self.doReplaceDQuote:
            logger.info("Using straight double quotes, so disabling auto-replace")
            self.doReplaceDQuote = False

        return True

    def saveConfig(self) -> bool:
        """Save the current preferences to file."""
        logger.debug("Saving config file")

        conf = NWConfigParser()

        conf["Meta"] = {
            "timestamp":    formatTimeStamp(time()),
        }

        conf["Main"] = {
            "theme":        str(self.guiTheme),
            "syntax":       str(self.guiSyntax),
            "font":         str(self.guiFont),
            "fontsize":     str(self.guiFontSize),
            "localisation": str(self.guiLocale),
            "hidevscroll":  str(self.hideVScroll),
            "hidehscroll":  str(self.hideHScroll),
            "lastnotes":    str(self.lastNotes),
            "lastpath":     str(self._lastPath),
        }

        conf["Sizes"] = {
            "mainwindow":   self._packList(self._mainWinSize),
            "preferences":  self._packList(self._prefsWinSize),
            "projloadcols": self._packList(self._projLoadCols),
            "mainpane":     self._packList(self._mainPanePos),
            "viewpane":     self._packList(self._viewPanePos),
            "outlinepane":  self._packList(self._outlnPanePos),
        }

        conf["Project"] = {
            "autosaveproject": str(self.autoSaveProj),
            "autosavedoc":     str(self.autoSaveDoc),
            "emphlabels":      str(self.emphLabels),
            "backuppath":      str(self._backupPath),
            "backuponclose":   str(self.backupOnClose),
            "askbeforebackup": str(self.askBeforeBackup),
        }

        conf["Editor"] = {
            "textfont":        str(self.textFont),
            "textsize":        str(self.textSize),
            "width":           str(self.textWidth),
            "margin":          str(self.textMargin),
            "tabwidth":        str(self.tabWidth),
            "focuswidth":      str(self.focusWidth),
            "hidefocusfooter": str(self.hideFocusFooter),
            "justify":         str(self.doJustify),
            "autoselect":      str(self.autoSelect),
            "autoreplace":     str(self.doReplace),
            "repsquotes":      str(self.doReplaceSQuote),
            "repdquotes":      str(self.doReplaceDQuote),
            "repdash":         str(self.doReplaceDash),
            "repdots":         str(self.doReplaceDots),
            "scrollpastend":   str(self.scrollPastEnd),
            "autoscroll":      str(self.autoScroll),
            "autoscrollpos":   str(self.autoScrollPos),
            "fmtsquoteopen":   str(self.fmtSQuoteOpen),
            "fmtsquoteclose":  str(self.fmtSQuoteClose),
            "fmtdquoteopen":   str(self.fmtDQuoteOpen),
            "fmtdquoteclose":  str(self.fmtDQuoteClose),
            "fmtpadbefore":    str(self.fmtPadBefore),
            "fmtpadafter":     str(self.fmtPadAfter),
            "fmtpadthin":      str(self.fmtPadThin),
            "spellcheck":      str(self.spellLanguage),
            "showtabsnspaces": str(self.showTabsNSpaces),
            "showlineendings": str(self.showLineEndings),
            "showmultispaces": str(self.showMultiSpaces),
            "wordcounttimer":  str(self.wordCountTimer),
            "bigdoclimit":     str(self.bigDocLimit),
            "incnoteswcount":  str(self.incNotesWCount),
            "showfullpath":    str(self.showFullPath),
            "highlightquotes": str(self.highlightQuotes),
            "allowopensquote": str(self.allowOpenSQuote),
            "allowopendquote": str(self.allowOpenDQuote),
            "highlightemph":   str(self.highlightEmph),
            "stopwhenidle":    str(self.stopWhenIdle),
            "useridletime":    str(self.userIdleTime),
        }

        conf["State"] = {
            "showrefpanel":    str(self.showRefPanel),
            "viewcomments":    str(self.viewComments),
            "viewsynopsis":    str(self.viewSynopsis),
            "searchcase":      str(self.searchCase),
            "searchword":      str(self.searchWord),
            "searchregex":     str(self.searchRegEx),
            "searchloop":      str(self.searchLoop),
            "searchnextfile":  str(self.searchNextFile),
            "searchmatchcap":  str(self.searchMatchCap),
        }

        # Write config file
        cnfPath = self._confPath / nwFiles.CONF_FILE
        try:
            with open(cnfPath, mode="w", encoding="utf-8") as outFile:
                conf.write(outFile)
        except Exception as exc:
            logger.error("Could not save config file")
            logException()
            self._hasError = True
            self._errData.append("Could not save config file")
            self._errData.append(formatException(exc))
            return False

        return True

    ##
    #  Internal Functions
    ##

    def _packList(self, data: list) -> str:
        """Pack a list of items into a comma-separated string for saving
        to the config file.
        """
        return ", ".join([str(inVal) for inVal in data])

    def _checkOptionalPackages(self) -> None:
        """Check optional packages used by some features."""
        try:
            import enchant  # noqa: F401
        except ImportError:
            self.hasEnchant = False
            logger.debug("Checking package 'pyenchant': Missing")
        else:
            self.hasEnchant = True
            logger.debug("Checking package 'pyenchant': OK")
        return

# END Class Config


class RecentProjects:

    def __init__(self, config: Config) -> None:
        self._conf = config
        self._data = {}
        return

    def loadCache(self) -> bool:
        """Load the cache file for recent projects."""
        self._data = {}

        cacheFile = self._conf.dataPath(nwFiles.RECENT_FILE)
        if not cacheFile.is_file():
            return True

        try:
            with open(cacheFile, mode="r", encoding="utf-8") as inFile:
                theData = json.load(inFile)
            for projPath, theEntry in theData.items():
                self._data[projPath] = {
                    "title": theEntry.get("title", ""),
                    "words": theEntry.get("words", 0),
                    "time": theEntry.get("time", 0),
                }
        except Exception:
            logger.error("Could not load recent project cache")
            logException()
            return False

        return True

    def saveCache(self) -> bool:
        """Save the cache dictionary of recent projects."""
        cacheFile = self._conf.dataPath(nwFiles.RECENT_FILE)
        cacheTemp = cacheFile.with_suffix(".tmp")
        try:
            with open(cacheTemp, mode="w+", encoding="utf-8") as outFile:
                json.dump(self._data, outFile, indent=2)
            cacheTemp.replace(cacheFile)
        except Exception:
            logger.error("Could not save recent project cache")
            logException()
            return False

        return True

    def listEntries(self) -> list[tuple[str, str, int, int]]:
        """List all items in the cache."""
        return [
            (str(k), str(e["title"]), checkInt(e["words"], 0), checkInt(e["time"], 0))
            for k, e in self._data.items()
        ]

    def update(self, path: str | Path, title: str, words: int, saved: float | int) -> None:
        """Add or update recent cache information on a given project."""
        self._data[str(path)] = {
            "title": title,
            "words": int(words),
            "time": int(saved),
        }
        self.saveCache()
        return

    def remove(self, path: str | Path) -> None:
        """Try to remove a path from the recent projects cache."""
        if self._data.pop(str(path), None) is not None:
            logger.debug("Removed recent: %s", path)
            self.saveCache()
        return

# END Class RecentProjects
