# -*- coding: utf-8 -*-
"""
novelWriter – Project Index
===========================
Data class for the project index of tags, headers and references

File History:
Created: 2019-05-27 [0.1.4]

This file is a part of novelWriter
Copyright 2018–2021, 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/>.
"""

import nw
import logging
import json
import os

from time import time

from nw.constants import (
    nwFiles, nwKeyWords, nwItemType, nwItemClass, nwItemLayout, nwAlert
)
from nw.core.document import NWDoc
from nw.core.tools import countWords
from nw.common import isHandle, isTitleTag, isItemClass, isItemLayout

logger = logging.getLogger(__name__)

class NWIndex():

    H_VALID = ("H0", "H1", "H2", "H3", "H4")
    H_LEVEL = {"H0": 0, "H1": 1, "H2": 2, "H3": 3, "H4": 4}

    def __init__(self, theProject, theParent):

        # Internal
        self.mainConf    = nw.CONFIG
        self.theProject  = theProject
        self.theParent   = theParent
        self.indexBroken = False

        # Indices
        self._tagIndex   = {}
        self._refIndex   = {}
        self._novelIndex = {}
        self._noteIndex  = {}
        self._textCounts = {}

        # TimeStamps
        self._timeNovel = 0
        self._timeNotes = 0
        self._timeIndex = 0

        return

    ##
    #  Public Methods
    ##

    def clearIndex(self):
        """Clear the index dictionaries and time stamps.
        """
        self._tagIndex   = {}
        self._refIndex   = {}
        self._novelIndex = {}
        self._noteIndex  = {}
        self._textCounts = {}
        self._timeNovel  = 0
        self._timeNotes  = 0
        self._timeIndex  = 0
        return

    def deleteHandle(self, tHandle):
        """Delete all entries of a given document handle.
        """
        logger.debug("Removing item %s from the index" % tHandle)

        delTags = []
        for tTag in self._tagIndex:
            if self._tagIndex[tTag][1] == tHandle:
                delTags.append(tTag)

        for tTag in delTags:
            self._tagIndex.pop(tTag, None)

        self._refIndex.pop(tHandle, None)
        self._novelIndex.pop(tHandle, None)
        self._noteIndex.pop(tHandle, None)
        self._textCounts.pop(tHandle, None)

        return

    def reIndexHandle(self, tHandle):
        """Put a file back into the index. This is used when files are
        moved from the archive or trash folders back into the active
        project.
        """
        logger.debug("Re-indexing item %s" % tHandle)

        tItem = self.theProject.projTree[tHandle]
        if tItem is None:
            return False
        if tItem.itemType != nwItemType.FILE:
            return False

        theDoc = NWDoc(self.theProject, self.theParent)
        theText = theDoc.openDocument(tHandle, showStatus=False)
        if theText:
            self.scanText(tHandle, theText)

        return True

    def novelChangedSince(self, checkTime):
        """Check if the novel index has changed since a given time.
        """
        return self._timeNovel > checkTime

    def notesChangedSince(self, checkTime):
        """Check if the notes index has changed since a given time.
        """
        return self._timeNotes > checkTime

    def indexChangedSince(self, checkTime):
        """Check if the index has changed since a given time.
        """
        return self._timeIndex > checkTime

    ##
    #  Load and Save Index to/from File
    ##

    def loadIndex(self):
        """Load index from last session from the project meta folder.
        """
        theData   = {}
        indexFile = os.path.join(self.theProject.projMeta, nwFiles.INDEX_FILE)

        if os.path.isfile(indexFile):
            logger.debug("Loading index file")
            try:
                with open(indexFile, mode="r", encoding="utf8") as inFile:
                    theData = json.load(inFile)
            except Exception:
                logger.error("Failed to load index file")
                nw.logException()
                self.indexBroken = True
                self.theParent.makeAlert(
                    "Could not load cached index file. Rebuilding index.",
                    nwAlert.WARN
                )
                return False

            self._tagIndex   = theData.get("tagIndex", {})
            self._refIndex   = theData.get("refIndex", {})
            self._novelIndex = theData.get("novelIndex", {})
            self._noteIndex  = theData.get("noteIndex", {})
            self._textCounts = theData.get("textCounts", {})

            nowTime = round(time())
            self._timeNovel = nowTime
            self._timeNotes = nowTime
            self._timeIndex = nowTime

        self.checkIndex()

        return True

    def saveIndex(self):
        """Save the current index as a json file in the project meta
        data folder.
        """
        logger.debug("Saving index file")
        indexFile = os.path.join(self.theProject.projMeta, nwFiles.INDEX_FILE)

        try:
            with open(indexFile, mode="w+", encoding="utf8") as outFile:
                json.dump({
                    "tagIndex"   : self._tagIndex,
                    "refIndex"   : self._refIndex,
                    "novelIndex" : self._novelIndex,
                    "noteIndex"  : self._noteIndex,
                    "textCounts" : self._textCounts,
                }, outFile, indent=2)
        except Exception:
            logger.error("Failed to save index file")
            nw.logException()
            return False

        return True

    def checkIndex(self):
        """Check that the entries in the index are valid and contain the
        elements it should.
        """
        logger.debug("Checking index")
        tStart = time()

        try:
            self._checkTagIndex()
            self._checkRefIndex()
            self._checkNovelNoteIndex("novelIndex")
            self._checkNovelNoteIndex("noteIndex")
            self._checkTextCounts()
            self.indexBroken = False

        except Exception:
            logger.error("Error while checking index")
            nw.logException()
            self.indexBroken = True

        tEnd = time()
        logger.debug("Index check took %.3f ms" % ((tEnd - tStart)*1000))
        logger.debug("Index check complete")

        if self.indexBroken:
            self.clearIndex()

        return

    ##
    #  Index Building
    ##

    def scanText(self, tHandle, theText):
        """Scan a piece of text associated with a handle. This will
        update the indices accordingly. This function takes the handle
        and text as separate inputs as we want to primarily scan the
        files before we save them, unless we're rebuilding the index.
        """
        theItem = self.theProject.projTree[tHandle]
        theRoot = self.theProject.projTree.getRootItem(tHandle)

        if theItem is None:
            logger.info("Not indexing unknown item %s" % tHandle)
            return False
        if theItem.itemType != nwItemType.FILE:
            logger.info("Not indexing non-file item %s" % tHandle)
            return False
        if theItem.itemLayout == nwItemLayout.NO_LAYOUT:
            logger.info("Not indexing no-layout item %s" % tHandle)
            return False
        if theItem.itemParent is None:
            logger.info("Not indexing orphaned item %s" % tHandle)
            return False

        # Run word counter for the whole text
        cC, wC, pC = countWords(theText)
        self._textCounts[tHandle] = [cC, wC, pC]

        # If the file is archived or trashed, we don't index the file itself
        if self.theProject.projTree.isTrashRoot(theItem.itemParent):
            logger.info("Not indexing trash item %s" % tHandle)
            return False
        if theRoot.itemClass == nwItemClass.ARCHIVE:
            logger.info("Not indexing archived item %s" % tHandle)
            return False

        itemClass  = theItem.itemClass
        itemLayout = theItem.itemLayout

        logger.debug("Indexing item with handle %s" % tHandle)

        # Check file type, and reset its old index
        # Also add a dummy entry T000000 in case the file has no title
        self._refIndex[tHandle] = {}
        self._refIndex[tHandle]["T000000"] = {
            "tags"    : [],
            "updated" : round(time()),
        }
        if itemLayout == nwItemLayout.NOTE:
            self._novelIndex.pop(tHandle, None)
            self._noteIndex[tHandle] = {}
            isNovel = False
        else:
            self._novelIndex[tHandle] = {}
            self._noteIndex.pop(tHandle, None)
            isNovel = True

        # Also clear references to file in tag index
        clearTags = []
        for aTag in self._tagIndex:
            if self._tagIndex[aTag][1] == tHandle:
                clearTags.append(aTag)
        for aTag in clearTags:
            self._tagIndex.pop(aTag)

        nLine  = 0
        nTitle = 0
        theLines = theText.splitlines()
        for aLine in theLines:
            aLine  = aLine
            nLine += 1
            nChar  = len(aLine.strip())
            if nChar == 0:
                continue

            if aLine.startswith("#"):
                isTitle = self._indexTitle(tHandle, isNovel, aLine, nLine, itemLayout)
                if isTitle and nLine > 0:
                    if nTitle > 0:
                        lastText = "\n".join(theLines[nTitle-1:nLine-1])
                        self._indexWordCounts(tHandle, isNovel, lastText, nTitle)
                    nTitle = nLine

            elif aLine.startswith("@"):
                self._indexNoteRef(tHandle, aLine, nLine, nTitle)
                self._indexTag(tHandle, aLine, nLine, nTitle, itemClass)

            elif aLine.startswith("%"):
                if nTitle > 0:
                    toCheck = aLine[1:].lstrip()
                    synTag = toCheck[:9].lower()
                    tLen = len(aLine)
                    cLen = len(toCheck)
                    cOff = tLen - cLen
                    if synTag == "synopsis:":
                        self._indexSynopsis(tHandle, isNovel, aLine[cOff+9:].strip(), nTitle)

        # Count words for remaining text after last heading
        if nTitle > 0:
            lastText = "\n".join(theLines[nTitle-1:])
            self._indexWordCounts(tHandle, isNovel, lastText, nTitle)

        # Index page with no titles and references
        if nTitle == 0:
            self._indexPage(tHandle, isNovel, itemLayout)
            self._indexWordCounts(tHandle, isNovel, theText, nTitle)

        # Update timestamps for index changes
        nowTime = round(time())
        self._timeIndex = nowTime
        if isNovel:
            self._timeNovel = nowTime
        else:
            self._timeNotes = nowTime

        return True

    ##
    #  Internal Indexers
    ##

    def _indexTitle(self, tHandle, isNovel, aLine, nLine, itemLayout):
        """Save information about the title and its location in the
        file to the index.
        """
        if aLine.startswith("# "):
            hDepth = "H1"
            hText  = aLine[2:].strip()
        elif aLine.startswith("## "):
            hDepth = "H2"
            hText  = aLine[3:].strip()
        elif aLine.startswith("### "):
            hDepth = "H3"
            hText  = aLine[4:].strip()
        elif aLine.startswith("#### "):
            hDepth = "H4"
            hText  = aLine[5:].strip()
        else:
            return False

        sTitle = "T%06d" % nLine
        self._refIndex[tHandle][sTitle] = {
            "tags"    : [],
            "updated" : round(time()),
        }
        theData = {
            "level"    : hDepth,
            "title"    : hText,
            "layout"   : itemLayout.name,
            "synopsis" : "",
            "cCount"   : 0,
            "wCount"   : 0,
            "pCount"   : 0,
            "updated"  : round(time()),
        }

        if hText != "":
            if isNovel:
                if tHandle in self._novelIndex:
                    self._novelIndex[tHandle][sTitle] = theData
            else:
                if tHandle in self._noteIndex:
                    self._noteIndex[tHandle][sTitle] = theData

        return True

    def _indexPage(self, tHandle, isNovel, itemLayout):
        """Index a page with no title.
        """
        theData = {
            "level"    : "H0",
            "title"    : "Untitled Page",
            "layout"   : itemLayout.name,
            "synopsis" : "",
            "cCount"   : 0,
            "wCount"   : 0,
            "pCount"   : 0,
            "updated"  : round(time()),
        }

        if isNovel:
            if tHandle in self._novelIndex:
                self._novelIndex[tHandle]["T000000"] = theData
        else:
            if tHandle in self._noteIndex:
                self._noteIndex[tHandle]["T000000"] = theData

        return

    def _indexWordCounts(self, tHandle, isNovel, theText, nTitle):
        """Count text stats and save the counts to the index.
        """
        cC, wC, pC = countWords(theText)
        sTitle = "T%06d" % nTitle
        if isNovel:
            if tHandle in self._novelIndex:
                if sTitle in self._novelIndex[tHandle]:
                    self._novelIndex[tHandle][sTitle]["cCount"] = cC
                    self._novelIndex[tHandle][sTitle]["wCount"] = wC
                    self._novelIndex[tHandle][sTitle]["pCount"] = pC
                    self._novelIndex[tHandle][sTitle]["updated"] = round(time())
        else:
            if tHandle in self._noteIndex:
                if sTitle in self._noteIndex[tHandle]:
                    self._noteIndex[tHandle][sTitle]["cCount"] = cC
                    self._noteIndex[tHandle][sTitle]["wCount"] = wC
                    self._noteIndex[tHandle][sTitle]["pCount"] = pC
                    self._noteIndex[tHandle][sTitle]["updated"] = round(time())
        return

    def _indexSynopsis(self, tHandle, isNovel, theText, nTitle):
        """Save the synopsis to the index.
        """
        sTitle = "T%06d" % nTitle
        if isNovel:
            if tHandle in self._novelIndex:
                if sTitle in self._novelIndex[tHandle]:
                    self._novelIndex[tHandle][sTitle]["synopsis"] = theText
                    self._novelIndex[tHandle][sTitle]["updated"] = round(time())
        else:
            if tHandle in self._noteIndex:
                if sTitle in self._noteIndex[tHandle]:
                    self._noteIndex[tHandle][sTitle]["synopsis"] = theText
                    self._noteIndex[tHandle][sTitle]["updated"] = round(time())
        return

    def _indexNoteRef(self, tHandle, aLine, nLine, nTitle):
        """Validate and save the information about a reference to a tag
        in another file.
        """
        isValid, theBits, _ = self.scanThis(aLine)
        if not isValid or len(theBits) == 0:
            return False

        sTitle = "T%06d" % nTitle
        if sTitle in self._refIndex[tHandle] and theBits[0] != nwKeyWords.TAG_KEY:
            for aVal in theBits[1:]:
                self._refIndex[tHandle][sTitle]["tags"].append([nLine, theBits[0], aVal])

        return True

    def _indexTag(self, tHandle, aLine, nLine, nTitle, itemClass):
        """Validate and save the information from a tag.
        """
        isValid, theBits, thePos = self.scanThis(aLine)
        if not isValid or len(theBits) != 2:
            return False

        if theBits[0] == nwKeyWords.TAG_KEY:
            sTitle = "T%06d" % nTitle
            self._tagIndex[theBits[1]] = [nLine, tHandle, itemClass.name, sTitle]

        return True

    ##
    #  Check @ Lines
    ##

    def scanThis(self, aLine):
        """Scan a line starting with @ to check that it's valid. Then
        split it up into its elements and positions as two arrays.
        """
        theBits = [] # The elements of the string
        thePos  = [] # The absolute position of each element

        aLine = aLine.rstrip() # Remove all trailing white spaces
        nChar = len(aLine)
        if nChar < 2:
            return False, theBits, thePos
        if aLine[0] != "@":
            return False, theBits, thePos

        cKey, _, cVals = aLine.partition(":")
        sKey = cKey.strip()
        if sKey == "@":
            return False, theBits, thePos

        cPos = 0
        theBits.append(sKey)
        thePos.append(cPos)
        cPos += len(cKey) + 1

        if not cVals:
            # No values, so we're done
            return True, theBits, thePos

        for cVal in cVals.split(","):
            sVal = cVal.strip()
            rLen = len(cVal.lstrip())
            tLen = len(cVal)
            theBits.append(sVal)
            thePos.append(cPos + tLen - rLen)
            cPos += tLen + 1

        return True, theBits, thePos

    def checkThese(self, theBits, tItem):
        """Check the tags against the index to see if they are valid
        tags. This is needed for syntax highlighting.
        """
        nBits = len(theBits)
        isGood = [False]*nBits
        if nBits == 0:
            return []

        # Check that the key is valid
        isGood[0] = theBits[0] in nwKeyWords.VALID_KEYS
        if not isGood[0] or nBits == 1:
            return isGood

        # If we have a tag, only the first value is accepted, the rest
        # is ignored
        if theBits[0] == nwKeyWords.TAG_KEY and nBits > 1:
            isGood[0] = True
            if theBits[1] in self._tagIndex:
                if self._tagIndex[theBits[1]][1] == tItem.itemHandle:
                    isGood[1] = True
                else:
                    isGood[1] = False
            else:
                isGood[1] = True
            return isGood

        # If we're still here, we better check that the references exist
        for n in range(1, nBits):
            if theBits[n] in self._tagIndex:
                isGood[n] = nwKeyWords.KEY_CLASS[theBits[0]].name == self._tagIndex[theBits[n]][2]

        return isGood

    ##
    #  Extract Data
    ##

    def novelStructure(self, skipExcluded=True):
        """Iterate over all titles in the novel, in the correct order as
        they appear in the tree view and in the respective document
        files, but skipping all note files.
        """
        for tHandle in self._listNovelHandles(skipExcluded):
            for sTitle in sorted(self._novelIndex[tHandle]):
                tKey = "%s:%s" % (tHandle, sTitle)
                yield tKey, tHandle, sTitle, self._novelIndex[tHandle][sTitle]

    def getNovelWordCount(self, skipExcluded=True):
        """Count the number of words in the novel project.
        """
        wCount = 0
        for tHandle in self._listNovelHandles(skipExcluded):
            for sTitle in self._novelIndex[tHandle]:
                wCount += self._novelIndex[tHandle][sTitle]["wCount"]

        return wCount

    def getNovelTitleCounts(self, skipExcluded=True):
        """Count the number of titles in the novel project.
        """
        hCount = [0, 0, 0, 0, 0]
        for tHandle in self._listNovelHandles(skipExcluded):
            for sTitle in self._novelIndex[tHandle]:
                theData = self._novelIndex[tHandle][sTitle]
                iLevel = self.H_LEVEL.get(theData["level"], 0)
                hCount[iLevel] += 1

        return hCount

    def getHandleWordCounts(self, tHandle):
        """Get all header word counts for a specific handle.
        """
        theCounts = []
        hRecord = self._novelIndex.get(tHandle, None)
        if hRecord is None:
            hRecord = self._noteIndex.get(tHandle, None)
        if hRecord is None:
            return theCounts

        for sTitle, sData in hRecord.items():
            theCounts.append(("%s:%s" % (tHandle, sTitle), sData["wCount"]))

        return theCounts

    def getHandleHeaders(self, tHandle):
        """Get all headers for a specific handle.
        """
        theHeaders = []
        hRecord = self._novelIndex.get(tHandle, None)
        if hRecord is None:
            hRecord = self._noteIndex.get(tHandle, None)
        if hRecord is None:
            return theHeaders

        for sTitle, sData in hRecord.items():
            theHeaders.append((sTitle, sData["level"], sData["title"]))

        return theHeaders

    def getTableOfContents(self, maxDepth, skipExcluded=True):
        """Generate a table of contents up to a maxiumum depth.
        """
        tOrder = []
        tData = {}
        pKey = None
        for tHandle in self._listNovelHandles(skipExcluded):
            for sTitle in sorted(self._novelIndex[tHandle]):
                tKey = "%s:%s" % (tHandle, sTitle)
                theData = self._novelIndex[tHandle][sTitle]
                iLevel = self.H_LEVEL.get(theData["level"], 0)
                if iLevel > maxDepth:
                    if pKey in tData:
                        theData["wCount"]
                        tData[pKey]["words"] += theData["wCount"]
                else:
                    pKey = tKey
                    tOrder.append(tKey)
                    tData[tKey] = {
                        "level": iLevel,
                        "title": theData["title"],
                        "words": theData["wCount"],
                    }

        theToC = []
        for tKey in tOrder:
            theToC.append((
                tKey,
                tData[tKey]["level"],
                tData[tKey]["title"],
                tData[tKey]["words"],
            ))

        return theToC

    def getCounts(self, tHandle, sTitle=None):
        """Returns the counts for a file, or a section of a file
        starting at title sTitle if it is provided.
        """
        cC = 0
        wC = 0
        pC = 0

        if sTitle is None:
            if tHandle in self._textCounts:
                cC = self._textCounts[tHandle][0]
                wC = self._textCounts[tHandle][1]
                pC = self._textCounts[tHandle][2]
        else:
            if tHandle in self._novelIndex:
                if sTitle in self._novelIndex[tHandle]:
                    cC = self._novelIndex[tHandle][sTitle]["cCount"]
                    wC = self._novelIndex[tHandle][sTitle]["wCount"]
                    pC = self._novelIndex[tHandle][sTitle]["pCount"]
            elif tHandle in self._noteIndex:
                if sTitle in self._noteIndex[tHandle]:
                    cC = self._noteIndex[tHandle][sTitle]["cCount"]
                    wC = self._noteIndex[tHandle][sTitle]["wCount"]
                    pC = self._noteIndex[tHandle][sTitle]["pCount"]

        return cC, wC, pC

    def getReferences(self, tHandle, sTitle=None):
        """Extract all references made in a file, and optionally title
        section. sTitle must be a string.
        """
        theRefs = {}
        for tKey in nwKeyWords.KEY_CLASS:
            theRefs[tKey] = []

        if tHandle not in self._refIndex:
            return theRefs

        for refTitle in self._refIndex[tHandle]:
            for aTag in self._refIndex[tHandle][refTitle].get("tags", []):
                if len(aTag) == 3 and (sTitle is None or sTitle == refTitle):
                    theRefs[aTag[1]].append(aTag[2])

        return theRefs

    def getNovelData(self, tHandle, sTitle):
        """Return the novel data of a given handle and title.
        """
        if tHandle in self._novelIndex:
            if sTitle in self._novelIndex[tHandle]:
                return self._novelIndex[tHandle][sTitle]
        return None

    def getBackReferenceList(self, tHandle):
        """Build a list of files referring back to our file, specified
        by tHandle.
        """
        theRefs = {}
        if tHandle is None:
            return theRefs

        theTags = set()
        for tTag in self._tagIndex:
            if tHandle == self._tagIndex[tTag][1]:
                theTags.add(tTag)

        if theTags:
            for tHandle in self._refIndex:
                for sTitle in self._refIndex[tHandle]:
                    for _, _, tTag in self._refIndex[tHandle][sTitle]["tags"]:
                        if tTag in theTags and tHandle not in theRefs:
                            theRefs[tHandle] = sTitle

        return theRefs

    def getTagSource(self, theTag):
        """Return the source location of a given tag.
        """
        if theTag in self._tagIndex:
            theRef = self._tagIndex[theTag]
            if len(theRef) == 4:
                return theRef[1], theRef[0], theRef[3]
        return None, 0, "T000000"

    ##
    #  Internal Functions
    ##

    def _listNovelHandles(self, skipExcluded):
        """Return a list of all handles that exist in the novel index.
        """
        theHandles = []
        for tItem in self.theProject.projTree:
            if tItem is None:
                continue
            if not tItem.isExported and skipExcluded:
                continue
            if tItem.itemHandle in self._novelIndex:
                theHandles.append(tItem.itemHandle)

        return theHandles

    ##
    #  Index Checkers
    ##

    def _checkTagIndex(self):
        """Scan the tag index for errors.
        Waring: This function raises exceptions.
        """
        for tTag in self._tagIndex:
            if not isinstance(tTag, str):
                raise KeyError("tagIndex key is not a string")

            tEntry = self._tagIndex[tTag]
            if len(tEntry) != 4:
                raise IndexError("tagIndex[a] expected 4 values")
            if not isinstance(tEntry[0], int):
                raise ValueError("tagIndex[a][0] is not an integer")
            if not isHandle(tEntry[1]):
                raise ValueError("tagIndex[a][1] is not a handle")
            if not isItemClass(tEntry[2]):
                raise ValueError("tagIndex[a][2] is not an nwItemClass")
            if not isTitleTag(tEntry[3]):
                raise ValueError("tagIndex[a][3] is not a title tag")

        return

    def _checkRefIndex(self):
        """Scan the reference index for errors.
        Waring: This function raises exceptions.
        """
        for tHandle in self._refIndex:
            if not isHandle(tHandle):
                raise KeyError("refIndex key is not a handle")

            hEntry = self._refIndex[tHandle]
            for sTitle in hEntry:
                if not isTitleTag(sTitle):
                    raise KeyError("refIndex[a] key is not a title tag")

                sEntry = hEntry[sTitle]
                if "tags" not in sEntry:
                    raise KeyError("refIndex[a][b] has no 'tag' key")
                for tEntry in sEntry["tags"]:
                    if len(tEntry) != 3:
                        raise IndexError("refIndex[a][b][tags][i] expected 3 values")
                    if not isinstance(tEntry[0], int):
                        raise ValueError("refIndex[a][b][tags][i][0] is not an integer")
                    if not tEntry[1] in nwKeyWords.VALID_KEYS:
                        raise ValueError("refIndex[a][b][tags][i][1] is not a keyword")
                    if not isinstance(tEntry[2], str):
                        raise ValueError("refIndex[a][b][tags][i][2] is not a string")

                if "updated" not in sEntry:
                    raise KeyError("refIndex[a][b] has no 'updated' key")
                if not isinstance(sEntry["updated"], int):
                    raise ValueError("%refIndex[a][b][updated] is not an integer")

        return

    def _checkNovelNoteIndex(self, idxName):
        """Scan the novel or note index for errors.
        Waring: This function raises exceptions.
        """
        if idxName == "novelIndex":
            theIndex = self._novelIndex
        elif idxName == "noteIndex":
            theIndex = self._noteIndex
        else:
            raise IndexError("Unknown index %s" % idxName)

        for tHandle in theIndex:
            if not isHandle(tHandle):
                raise KeyError("%s key is not a handle" % idxName)

            hEntry = theIndex[tHandle]
            for sTitle in theIndex[tHandle]:
                if not isTitleTag(sTitle):
                    raise KeyError("%s[a] key is not a title tag" % idxName)

                sEntry = hEntry[sTitle]
                if len(sEntry) != 8:
                    raise IndexError("%s[a][b] expected 8 values" % idxName)

                if "level" not in sEntry:
                    raise KeyError("%s[a][b] has no 'level' key" % idxName)
                if "title" not in sEntry:
                    raise KeyError("%s[a][b] has no 'title' key" % idxName)
                if "layout" not in sEntry:
                    raise KeyError("%s[a][b] has no 'layout' key" % idxName)
                if "synopsis" not in sEntry:
                    raise KeyError("%s[a][b] has no 'synopsis' key" % idxName)
                if "cCount" not in sEntry:
                    raise KeyError("%s[a][b] has no 'cCount' key" % idxName)
                if "wCount" not in sEntry:
                    raise KeyError("%s[a][b] has no 'wCount' key" % idxName)
                if "pCount" not in sEntry:
                    raise KeyError("%s[a][b] has no 'pCount' key" % idxName)
                if "updated" not in sEntry:
                    raise KeyError("%s[a][b] has no 'updated' key" % idxName)

                if not sEntry["level"] in self.H_VALID:
                    raise ValueError("%s[a][b][level] is not a header level" % idxName)
                if not isinstance(sEntry["title"], str):
                    raise ValueError("%s[a][b][title] is not a string" % idxName)
                if not isItemLayout(sEntry["layout"]):
                    raise ValueError("%s[a][b][layout] is not an nwItemLayout" % idxName)
                if not isinstance(sEntry["synopsis"], str):
                    raise ValueError("%s[a][b][synopsis] is not a string" % idxName)
                if not isinstance(sEntry["cCount"], int):
                    raise ValueError("%s[a][b][cCount] is not an integer" % idxName)
                if not isinstance(sEntry["wCount"], int):
                    raise ValueError("%s[a][b][wCount] is not an integer" % idxName)
                if not isinstance(sEntry["pCount"], int):
                    raise ValueError("%s[a][b][pCount] is not an integer" % idxName)
                if not isinstance(sEntry["updated"], int):
                    raise ValueError("%s[a][b][updated] is not an integer" % idxName)

        return

    def _checkTextCounts(self):
        """Scan the text counts index for errors.
        Waring: This function raises exceptions.
        """
        for tHandle in self._textCounts:
            if not isHandle(tHandle):
                raise KeyError("textCounts key is not a handle")

            tEntry = self._textCounts[tHandle]
            if len(tEntry) != 3:
                raise IndexError("textCounts[a] expected 3 values")
            if not isinstance(tEntry[0], int):
                raise ValueError("textCounts[a][0] is not an integer")
            if not isinstance(tEntry[1], int):
                raise ValueError("textCounts[a][1] is not an integer")
            if not isinstance(tEntry[2], int):
                raise ValueError("textCounts[a][2] is not an integer")

        return

# END Class NWIndex
