"""
novelWriter – ODT Text Converter
================================

File History:
Created: 2021-01-26 [1.2b1] ToOdt
Created: 2021-01-27 [1.2b1] ODTParagraphStyle
Created: 2021-01-27 [1.2b1] ODTTextStyle
Created: 2021-08-14 [1.5b1] XMLParagraph

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 logging
from pathlib import Path
import xml.etree.ElementTree as ET

from hashlib import sha256
from zipfile import ZipFile
from datetime import datetime

from novelwriter import __version__
from novelwriter.common import xmlIndent
from novelwriter.constants import nwKeyWords, nwLabels
from novelwriter.core.project import NWProject
from novelwriter.core.tokenizer import Tokenizer, stripEscape

logger = logging.getLogger(__name__)

# Main XML NameSpaces
XML_NS = {
    "manifest": "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0",
    "office":   "urn:oasis:names:tc:opendocument:xmlns:office:1.0",
    "style":    "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
    "loext":    "urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0",
    "text":     "urn:oasis:names:tc:opendocument:xmlns:text:1.0",
    "meta":     "urn:oasis:names:tc:opendocument:xmlns:meta:1.0",
    "fo":       "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0",
    "dc":       "http://purl.org/dc/elements/1.1/",
}
for ns, uri in XML_NS.items():
    ET.register_namespace(ns, uri)


def _mkTag(ns: str, tag: str) -> str:
    """Assemble namespace and tag name."""
    uri = XML_NS.get(ns, "")
    if uri:
        return f"{{{uri}}}{tag}"
    logger.warning("Missing xml namespace '%s'", ns)
    return tag


# Mimetype and Version
X_MIME = "application/vnd.oasis.opendocument.text"
X_VERS = "1.3"

# Text Formatting Tags
TAG_BR   = _mkTag("text", "line-break")
TAG_SPC  = _mkTag("text", "s")
TAG_NSPC = _mkTag("text", "c")
TAG_TAB  = _mkTag("text", "tab")
TAG_SPAN = _mkTag("text", "span")
TAG_STNM = _mkTag("text", "style-name")

# Formatting Codes
X_BLD = 0x01  # Bold format
X_ITA = 0x02  # Italic format
X_DEL = 0x04  # Strikethrough format

# Formatting Masks
M_BLD = ~X_BLD
M_ITA = ~X_ITA
M_DEL = ~X_DEL


class ToOdt(Tokenizer):
    """Core: Open Document Writer

    Extend the Tokenizer class to writer Open Document files. The output
    should conform to the 1.3 Extended standard.

    Test with: https://odfvalidator.org/
    """

    def __init__(self, project: NWProject, isFlat: bool):
        super().__init__(project)

        self._isFlat = isFlat  # Flat: .fodt, otherwise .odt

        self._dFlat = ET.Element("")  # FODT file XML root
        self._dCont = ET.Element("")  # ODT content.xml root
        self._dMeta = ET.Element("")  # ODT meta.xml root
        self._dStyl = ET.Element("")  # ODT styles.xml root

        self._xMeta = ET.Element("")  # Office meta root
        self._xFont = ET.Element("")  # Office font face declaration
        self._xFnt2 = ET.Element("")  # Office font face declaration, secondary
        self._xStyl = ET.Element("")  # Office styles root
        self._xAuto = ET.Element("")  # Office auto-styles root
        self._xAut2 = ET.Element("")  # Office auto-styles root, secondary
        self._xMast = ET.Element("")  # Office master-styles root
        self._xBody = ET.Element("")  # Office body root
        self._xText = ET.Element("")  # Office text root

        self._mainPara = {}  # User-accessible paragraph styles
        self._autoPara = {}  # Auto-generated paragraph styles
        self._autoText = {}  # Auto-generated text styles

        self._errData = []  # List of errors encountered

        # Properties
        self._textFont   = "Liberation Serif"
        self._textSize   = 12
        self._textFixed  = False
        self._colourHead = False
        self._headerText = ""

        # Internal
        self._fontFamily   = "&apos;Liberation Serif&apos;"
        self._fontPitch    = "variable"
        self._fSizeTitle   = "30pt"
        self._fSizeHead1   = "24pt"
        self._fSizeHead2   = "20pt"
        self._fSizeHead3   = "16pt"
        self._fSizeHead4   = "14pt"
        self._fSizeHead    = "14pt"
        self._fSizeText    = "12pt"
        self._fLineHeight  = "115%"
        self._fBlockIndent = "1.693cm"
        self._textAlign    = "left"
        self._dLanguage    = "en"
        self._dCountry     = "GB"

        # Text Margins
        self._mTopTitle = "0.423cm"
        self._mTopHead1 = "0.423cm"
        self._mTopHead2 = "0.353cm"
        self._mTopHead3 = "0.247cm"
        self._mTopHead4 = "0.247cm"
        self._mTopHead  = "0.423cm"
        self._mTopText  = "0.000cm"
        self._mTopMeta  = "0.000cm"

        self._mBotTitle = "0.212cm"
        self._mBotHead1 = "0.212cm"
        self._mBotHead2 = "0.212cm"
        self._mBotHead3 = "0.212cm"
        self._mBotHead4 = "0.212cm"
        self._mBotHead  = "0.212cm"
        self._mBotText  = "0.247cm"
        self._mBotMeta  = "0.106cm"

        # Document Size and Margins
        self._mDocWidth  = "21.0cm"
        self._mDocHeight = "29.7cm"
        self._mDocTop    = "2.000cm"
        self._mDocBtm    = "2.000cm"
        self._mDocLeft   = "2.000cm"
        self._mDocRight  = "2.000cm"

        # Colour
        self._colHead12 = None
        self._opaHead12 = None
        self._colHead34 = None
        self._opaHead34 = None
        self._colMetaTx = None
        self._opaMetaTx = None

        return

    ##
    #  Setters
    ##

    def setLanguage(self, language: str):
        """Set language for the document."""
        if language:
            langBits = language.split("_")
            self._dLanguage = langBits[0]
            if len(langBits) > 1:
                self._dCountry = langBits[1]
        return

    def setColourHeaders(self, state: bool):
        """Enable/disable coloured headings and comments."""
        self._colourHead = state
        return

    def setPageLayout(
        self, width: int | float, height: int | float,
        top: int | float, bottom: int | float, left: int | float, right: int | float
    ):
        """Set the document page size and margins in millimetres."""
        self._mDocWidth  = f"{width/10.0:.3f}cm"
        self._mDocHeight = f"{height/10.0:.3f}cm"
        self._mDocTop    = f"{top/10.0:.3f}cm"
        self._mDocBtm    = f"{bottom/10.0:.3f}cm"
        self._mDocLeft   = f"{left/10.0:.3f}cm"
        self._mDocRight  = f"{right/10.0:.3f}cm"
        return

    ##
    #  Class Methods
    ##

    def initDocument(self):
        """Initialises a new open document XML tree."""
        # Initialise Variables
        # ====================

        self._fontFamily = self._textFont
        if len(self._textFont.split()) > 1:
            self._fontFamily = f"'{self._textFont}'"
        self._fontPitch = "fixed" if self._textFixed else "variable"

        self._fSizeTitle = f"{round(2.50 * self._textSize):d}pt"
        self._fSizeHead1 = f"{round(2.00 * self._textSize):d}pt"
        self._fSizeHead2 = f"{round(1.60 * self._textSize):d}pt"
        self._fSizeHead3 = f"{round(1.30 * self._textSize):d}pt"
        self._fSizeHead4 = f"{round(1.15 * self._textSize):d}pt"
        self._fSizeHead  = f"{round(1.15 * self._textSize):d}pt"
        self._fSizeText  = f"{self._textSize:d}pt"

        mScale = self._lineHeight/1.15

        self._mTopTitle = self._emToCm(mScale * self._marginTitle[0])
        self._mTopHead1 = self._emToCm(mScale * self._marginHead1[0])
        self._mTopHead2 = self._emToCm(mScale * self._marginHead2[0])
        self._mTopHead3 = self._emToCm(mScale * self._marginHead3[0])
        self._mTopHead4 = self._emToCm(mScale * self._marginHead4[0])
        self._mTopHead  = self._emToCm(mScale * self._marginHead4[0])
        self._mTopText  = self._emToCm(mScale * self._marginText[0])
        self._mTopMeta  = self._emToCm(mScale * self._marginMeta[0])

        self._mBotTitle = self._emToCm(mScale * self._marginTitle[1])
        self._mBotHead1 = self._emToCm(mScale * self._marginHead1[1])
        self._mBotHead2 = self._emToCm(mScale * self._marginHead2[1])
        self._mBotHead3 = self._emToCm(mScale * self._marginHead3[1])
        self._mBotHead4 = self._emToCm(mScale * self._marginHead4[1])
        self._mBotHead  = self._emToCm(mScale * self._marginHead4[1])
        self._mBotText  = self._emToCm(mScale * self._marginText[1])
        self._mBotMeta  = self._emToCm(mScale * self._marginMeta[1])

        if self._colourHead:
            self._colHead12 = "#2a6099"
            self._opaHead12 = "100%"
            self._colHead34 = "#444444"
            self._opaHead34 = "100%"
            self._colMetaTx = "#813709"
            self._opaMetaTx = "100%"

        self._fLineHeight  = f"{round(100 * self._lineHeight):d}%"
        self._fBlockIndent = self._emToCm(self._blockIndent)
        self._textAlign    = "justify" if self._doJustify else "left"

        # Clear Errors
        self._errData = []

        # Document Header
        # ===============

        if self._headerText == "":
            theTitle = self._project.data.title or self._project.data.name
            theAuth = self._project.data.author
            self._headerText = f"{theTitle} / {theAuth} /"

        # Create Roots
        # ============

        tAttr = {}
        tAttr[_mkTag("office", "version")] = X_VERS

        fAttr = {}
        fAttr[_mkTag("style", "name")] = self._textFont
        fAttr[_mkTag("style", "font-pitch")] = self._fontPitch

        if self._isFlat:

            # FODT File
            # =========

            tAttr[_mkTag("office", "mimetype")] = X_MIME

            tFlat = _mkTag("office", "document")
            self._dFlat = ET.Element(tFlat, attrib=tAttr)

            self._xMeta = ET.SubElement(self._dFlat, _mkTag("office", "meta"))
            self._xFont = ET.SubElement(self._dFlat, _mkTag("office", "font-face-decls"))
            self._xStyl = ET.SubElement(self._dFlat, _mkTag("office", "styles"))
            self._xAuto = ET.SubElement(self._dFlat, _mkTag("office", "automatic-styles"))
            self._xMast = ET.SubElement(self._dFlat, _mkTag("office", "master-styles"))
            self._xBody = ET.SubElement(self._dFlat, _mkTag("office", "body"))

            ET.SubElement(self._xFont, _mkTag("style", "font-face"), attrib=fAttr)

        else:

            # ODT File
            # ========

            tCont = _mkTag("office", "document-content")
            tMeta = _mkTag("office", "document-meta")
            tStyl = _mkTag("office", "document-styles")

            # content.xml
            self._dCont = ET.Element(tCont, attrib=tAttr)
            self._xFont = ET.SubElement(self._dCont, _mkTag("office", "font-face-decls"))
            self._xAuto = ET.SubElement(self._dCont, _mkTag("office", "automatic-styles"))
            self._xBody = ET.SubElement(self._dCont, _mkTag("office", "body"))

            # meta.xml
            self._dMeta = ET.Element(tMeta, attrib=tAttr)
            self._xMeta = ET.SubElement(self._dMeta, _mkTag("office", "meta"))

            # styles.xml
            self._dStyl = ET.Element(tStyl, attrib=tAttr)
            self._xFnt2 = ET.SubElement(self._dStyl, _mkTag("office", "font-face-decls"))
            self._xStyl = ET.SubElement(self._dStyl, _mkTag("office", "styles"))
            self._xAut2 = ET.SubElement(self._dStyl, _mkTag("office", "automatic-styles"))
            self._xMast = ET.SubElement(self._dStyl, _mkTag("office", "master-styles"))

            ET.SubElement(self._xFont, _mkTag("style", "font-face"), attrib=fAttr)
            ET.SubElement(self._xFnt2, _mkTag("style", "font-face"), attrib=fAttr)

        # Finalise
        # ========

        self._xText = ET.SubElement(self._xBody, _mkTag("office", "text"))

        timeStamp = datetime.now().isoformat(sep="T", timespec="seconds")

        # Office Meta Data
        xMeta = ET.SubElement(self._xMeta, _mkTag("meta", "creation-date"))
        xMeta.text = timeStamp

        xMeta = ET.SubElement(self._xMeta, _mkTag("meta", "generator"))
        xMeta.text = f"novelWriter/{__version__}"

        xMeta = ET.SubElement(self._xMeta, _mkTag("meta", "initial-creator"))
        xMeta.text = self._project.data.author

        xMeta = ET.SubElement(self._xMeta, _mkTag("meta", "editing-cycles"))
        xMeta.text = str(self._project.data.saveCount)

        # Format is: PnYnMnDTnHnMnS
        # https://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#duration
        eT = self._project.data.editTime
        xMeta = ET.SubElement(self._xMeta, _mkTag("meta", "editing-duration"))
        xMeta.text = f"P{eT//86400:d}DT{eT%86400//3600:d}H{eT%3600//60:d}M{eT%60:d}S"

        # Dublin Core Meta Data
        xMeta = ET.SubElement(self._xMeta, _mkTag("dc", "title"))
        xMeta.text = self._project.data.title or self._project.data.name

        xMeta = ET.SubElement(self._xMeta, _mkTag("dc", "date"))
        xMeta.text = timeStamp

        xMeta = ET.SubElement(self._xMeta, _mkTag("dc", "creator"))
        xMeta.text = self._project.data.author

        self._pageStyles()
        self._defaultStyles()
        self._useableStyles()
        self._writeHeader()

        return

    def doConvert(self):
        """Convert the list of text tokens into XML elements."""
        self._result = ""  # Not used, but cleared just in case

        odtTags = {
            self.FMT_B_B: "_B",  # Bold open format
            self.FMT_B_E: "b_",  # Bold close format
            self.FMT_I_B: "I",   # Italic open format
            self.FMT_I_E: "i",   # Italic close format
            self.FMT_D_B: "_S",  # Strikethrough open format
            self.FMT_D_E: "s_",  # Strikethrough close format
        }

        thisPar = []
        thisFmt = []
        parStyle = None
        for tType, _, tText, tFormat, tStyle in self._tokens:

            # Styles
            oStyle = ODTParagraphStyle()
            if tStyle is not None:
                if tStyle & self.A_LEFT:
                    oStyle.setTextAlign("left")
                elif tStyle & self.A_RIGHT:
                    oStyle.setTextAlign("right")
                elif tStyle & self.A_CENTRE:
                    oStyle.setTextAlign("center")
                elif tStyle & self.A_JUSTIFY:
                    oStyle.setTextAlign("justify")

                if tStyle & self.A_PBB:
                    oStyle.setBreakBefore("page")

                if tStyle & self.A_PBA:
                    oStyle.setBreakAfter("page")

                if tStyle & self.A_Z_BTMMRG:
                    oStyle.setMarginBottom("0.000cm")
                if tStyle & self.A_Z_TOPMRG:
                    oStyle.setMarginTop("0.000cm")

                if tStyle & self.A_IND_L:
                    oStyle.setMarginLeft(self._fBlockIndent)
                if tStyle & self.A_IND_R:
                    oStyle.setMarginRight(self._fBlockIndent)

            # Process Text Types
            if tType == self.T_EMPTY:
                if len(thisPar) > 1 and parStyle is not None:
                    if self._doJustify:
                        parStyle.setTextAlign("left")

                if len(thisPar) > 0 and parStyle is not None:
                    tTemp = "\n".join(thisPar)
                    fTemp = " ".join(thisFmt)
                    tTxt = tTemp.rstrip()
                    tFmt = fTemp[:len(tTxt)]
                    self._addTextPar("Text_20_body", parStyle, tTxt, tFmt=tFmt)

                thisPar = []
                thisFmt = []
                parStyle = None

            elif tType == self.T_TITLE:
                tHead = tText.replace(r"\\", "\n")
                self._addTextPar("Title", oStyle, tHead, isHead=False)  # Title must be text:p

            elif tType == self.T_UNNUM:
                tHead = tText.replace(r"\\", "\n")
                self._addTextPar("Heading_20_2", oStyle, tHead, isHead=True, oLevel="2")

            elif tType == self.T_HEAD1:
                tHead = tText.replace(r"\\", "\n")
                self._addTextPar("Heading_20_1", oStyle, tHead, isHead=True, oLevel="1")

            elif tType == self.T_HEAD2:
                tHead = tText.replace(r"\\", "\n")
                self._addTextPar("Heading_20_2", oStyle, tHead, isHead=True, oLevel="2")

            elif tType == self.T_HEAD3:
                tHead = tText.replace(r"\\", "\n")
                self._addTextPar("Heading_20_3", oStyle, tHead, isHead=True, oLevel="3")

            elif tType == self.T_HEAD4:
                tHead = tText.replace(r"\\", "\n")
                self._addTextPar("Heading_20_4", oStyle, tHead, isHead=True, oLevel="4")

            elif tType == self.T_SEP:
                self._addTextPar("Separator", oStyle, tText)

            elif tType == self.T_SKIP:
                self._addTextPar("Separator", oStyle, "")

            elif tType == self.T_TEXT:
                if parStyle is None:
                    parStyle = oStyle

                tFmt = " "*len(tText)
                for xPos, xLen, xFmt in tFormat:
                    tFmt = tFmt[:xPos] + odtTags[xFmt] + tFmt[xPos+xLen:]

                tTxt = tText.rstrip()
                tFmt = tFmt[:len(tTxt)]
                thisPar.append(tTxt)
                thisFmt.append(tFmt)

            elif tType == self.T_SYNOPSIS and self._doSynopsis:
                tTemp, fTemp = self._formatSynopsis(tText)
                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)

            elif tType == self.T_COMMENT and self._doComments:
                tTemp, fTemp = self._formatComments(tText)
                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)

            elif tType == self.T_KEYWORD and self._doKeywords:
                tTemp, fTemp = self._formatKeywords(tText)
                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)

        return

    def closeDocument(self):
        """Return the serialised XML document"""
        # Build the auto-generated styles
        for styleName, styleObj in self._autoPara.values():
            styleObj.packXML(self._xAuto, styleName)
        for styleName, styleObj in self._autoText.values():
            styleObj.packXML(self._xAuto, styleName)
        return

    def saveFlatXML(self, path: str | Path):
        """Save the data to an .fodt file."""
        with open(path, mode="wb") as fObj:
            xml = ET.ElementTree(self._dFlat)
            xmlIndent(xml)
            xml.write(fObj, encoding="utf-8", xml_declaration=True)
        logger.info("Wrote file: %s", path)
        return

    def saveOpenDocText(self, path: str | Path):
        """Save the data to an .odt file."""
        mMani = _mkTag("manifest", "manifest")
        mVers = _mkTag("manifest", "version")
        mPath = _mkTag("manifest", "full-path")
        mType = _mkTag("manifest", "media-type")
        mFile = _mkTag("manifest", "file-entry")

        xMani = ET.Element(mMani, attrib={mVers: X_VERS})
        ET.SubElement(xMani, mFile, attrib={mPath: "/", mVers: X_VERS, mType: X_MIME})
        ET.SubElement(xMani, mFile, attrib={mPath: "settings.xml", mType: "text/xml"})
        ET.SubElement(xMani, mFile, attrib={mPath: "content.xml", mType: "text/xml"})
        ET.SubElement(xMani, mFile, attrib={mPath: "meta.xml", mType: "text/xml"})
        ET.SubElement(xMani, mFile, attrib={mPath: "styles.xml", mType: "text/xml"})

        oRoot = _mkTag("office", "document-settings")
        oVers = _mkTag("office", "version")
        xSett = ET.Element(oRoot, attrib={oVers: X_VERS})

        def putInZip(name, xObj, zipObj):
            with zipObj.open(name, mode="w") as fObj:
                xml = ET.ElementTree(xObj)
                xml.write(fObj, encoding="utf-8", xml_declaration=True)

        with ZipFile(path, mode="w") as outZip:
            outZip.writestr("mimetype", X_MIME)
            putInZip("META-INF/manifest.xml", xMani, outZip)
            putInZip("settings.xml", xSett, outZip)
            putInZip("content.xml", self._dCont, outZip)
            putInZip("meta.xml", self._dMeta, outZip)
            putInZip("styles.xml", self._dStyl, outZip)

        logger.info("Wrote file: %s", path)

        return

    ##
    #  Internal Functions
    ##

    def _formatSynopsis(self, text: str) -> tuple[str, str]:
        """Apply formatting to synopsis lines."""
        sSynop = self._localLookup("Synopsis")
        rTxt = "**{0}:** {1}".format(sSynop, text)
        rFmt = "_B{0} b_ {1}".format(" "*len(sSynop), " "*len(text))
        return rTxt, rFmt

    def _formatComments(self, text: str) -> tuple[str, str]:
        """Apply formatting to comments."""
        sComm = self._localLookup("Comment")
        rTxt = "**{0}:** {1}".format(sComm, text)
        rFmt = "_B{0} b_ {1}".format(" "*len(sComm), " "*len(text))
        return rTxt, rFmt

    def _formatKeywords(self, text: str) -> tuple[str, str]:
        """Apply formatting to keywords."""
        valid, bits, _ = self._project.index.scanThis("@"+text)
        if not valid or not bits:
            return "", ""

        rTxt = ""
        rFmt = ""
        if bits[0] in nwLabels.KEY_NAME:
            text = nwLabels.KEY_NAME[bits[0]]
            rTxt += "**{0}:** ".format(text)
            rFmt += "_B{0} b_ ".format(" "*len(text))
            if len(bits) > 1:
                if bits[0] == nwKeyWords.TAG_KEY:
                    rTxt += bits[1]
                    rFmt += " "*len(bits[1])
                else:
                    tTags = ", ".join(bits[1:])
                    rTxt += tTags
                    rFmt += (" "*len(tTags))

        return rTxt, rFmt

    def _addTextPar(
        self, styleName: str, oStyle: ODTParagraphStyle, tText: str, tFmt: str = "",
        isHead: bool = False, oLevel: str | None = None
    ):
        """Add a text paragraph to the text XML element."""
        tAttr = {}
        tAttr[_mkTag("text", "style-name")] = self._paraStyle(styleName, oStyle)
        if oLevel is not None:
            tAttr[_mkTag("text", "outline-level")] = oLevel

        pTag = "h" if isHead else "p"
        xElem = ET.SubElement(self._xText, _mkTag("text", pTag), attrib=tAttr)

        # It's important to set the initial text field to empty, otherwise
        # xmlIndent will add a line break if the first subelement is a span.
        xElem.text = ""

        if not tText:
            return

        ##
        #  Process Formatting
        ##

        if len(tText) != len(tFmt):
            # Generate an empty format if there isn't any or it doesn't match
            tFmt = " "*len(tText)

        # The formatting loop
        tTemp = ""
        xFmt = 0x00
        pFmt = 0x00
        pErr = 0

        parProc = XMLParagraph(xElem)

        for i, c in enumerate(tText):

            if tFmt[i] == " ":
                tTemp += c
            elif tFmt[i] == "_":
                continue
            elif tFmt[i] == "B":
                xFmt |= X_BLD
            elif tFmt[i] == "b":
                xFmt &= M_BLD
            elif tFmt[i] == "I":
                xFmt |= X_ITA
            elif tFmt[i] == "i":
                xFmt &= M_ITA
            elif tFmt[i] == "S":
                xFmt |= X_DEL
            elif tFmt[i] == "s":
                xFmt &= M_DEL
            else:
                pErr += 1

            if xFmt != pFmt:
                if pFmt == 0x00:
                    parProc.appendText(tTemp)
                    tTemp = ""
                else:
                    parProc.appendSpan(tTemp, self._textStyle(pFmt))
                    tTemp = ""

            pFmt = xFmt

        # Save what remains in the buffer
        if pFmt == 0x00:
            parProc.appendText(tTemp)
        else:
            parProc.appendSpan(tTemp, self._textStyle(pFmt))

        if pErr > 0:
            self._errData.append("Unknown format tag encountered")

        nErr, errMsg = parProc.checkError()
        if nErr > 0:  # pragma: no cover
            # This one should only capture bugs
            self._errData.append(errMsg)

        return

    def _paraStyle(self, parName: str, oStyle: ODTParagraphStyle) -> str:
        """Return a name for a style object."""
        refStyle = self._mainPara.get(parName, None)
        if refStyle is None:
            logger.error("Unknown paragraph style '%s'", parName)
            return "Standard"

        if not refStyle.checkNew(oStyle):
            return parName

        oStyle.setParentStyleName(parName)
        theID = oStyle.getID()
        if theID in self._autoPara:
            return self._autoPara[theID][0]

        newName = "P%d" % (len(self._autoPara) + 1)
        self._autoPara[theID] = (newName, oStyle)

        return newName

    def _textStyle(self, hFmt: int) -> str:
        """Return a text style for a given style code."""
        if hFmt in self._autoText:
            return self._autoText[hFmt][0]

        newName = "T%d" % (len(self._autoText) + 1)
        newStyle = ODTTextStyle()
        if hFmt & X_BLD:
            newStyle.setFontWeight("bold")
        if hFmt & X_ITA:
            newStyle.setFontStyle("italic")
        if hFmt & X_DEL:
            newStyle.setStrikeStyle("solid")
            newStyle.setStrikeType("single")

        self._autoText[hFmt] = (newName, newStyle)

        return newName

    def _emToCm(self, emVal: float) -> str:
        """Converts an em value to centimetres."""
        return f"{emVal*2.54/72*self._textSize:.3f}cm"

    ##
    #  Style Elements
    ##

    def _pageStyles(self):
        """Set the default page style."""
        tAttr = {}
        tAttr[_mkTag("style", "name")] = "PM1"
        if self._isFlat:
            xPage = ET.SubElement(self._xAuto, _mkTag("style", "page-layout"), attrib=tAttr)
        else:
            xPage = ET.SubElement(self._xAut2, _mkTag("style", "page-layout"), attrib=tAttr)

        tAttr = {}
        tAttr[_mkTag("fo", "page-width")]    = self._mDocWidth
        tAttr[_mkTag("fo", "page-height")]   = self._mDocHeight
        tAttr[_mkTag("fo", "margin-top")]    = self._mDocTop
        tAttr[_mkTag("fo", "margin-bottom")] = self._mDocBtm
        tAttr[_mkTag("fo", "margin-left")]   = self._mDocLeft
        tAttr[_mkTag("fo", "margin-right")]  = self._mDocRight
        tAttr[_mkTag("fo", "print-orientation")] = "portrait"
        ET.SubElement(xPage, _mkTag("style", "page-layout-properties"), attrib=tAttr)

        xHead = ET.SubElement(xPage, _mkTag("style", "header-style"))

        tAttr = {}
        tAttr[_mkTag("fo", "min-height")]    = "0.600cm"
        tAttr[_mkTag("fo", "margin-left")]   = "0.000cm"
        tAttr[_mkTag("fo", "margin-right")]  = "0.000cm"
        tAttr[_mkTag("fo", "margin-bottom")] = "0.500cm"
        ET.SubElement(xHead, _mkTag("style", "header-footer-properties"), attrib=tAttr)

        return

    def _defaultStyles(self):
        """Set the default styles."""
        # Add Paragraph Family Style
        # ==========================

        tAttr = {}
        tAttr[_mkTag("style", "family")] = "paragraph"
        xStyl = ET.SubElement(self._xStyl, _mkTag("style", "default-style"), attrib=tAttr)

        tAttr = {}
        tAttr[_mkTag("style", "line-break")]        = "strict"
        tAttr[_mkTag("style", "tab-stop-distance")] = "1.251cm"
        tAttr[_mkTag("style", "writing-mode")]      = "page"
        ET.SubElement(xStyl, _mkTag("style", "paragraph-properties"), attrib=tAttr)

        tAttr = {}
        tAttr[_mkTag("style", "font-name")]   = self._textFont
        tAttr[_mkTag("fo",    "font-family")] = self._fontFamily
        tAttr[_mkTag("fo",    "font-size")]   = self._fSizeText
        tAttr[_mkTag("fo",    "language")]    = self._dLanguage
        tAttr[_mkTag("fo",    "country")]     = self._dCountry
        ET.SubElement(xStyl, _mkTag("style", "text-properties"), attrib=tAttr)

        # Add Standard Paragraph Style
        # ============================

        tAttr = {}
        tAttr[_mkTag("style", "name")]   = "Standard"
        tAttr[_mkTag("style", "family")] = "paragraph"
        tAttr[_mkTag("style", "class")]  = "text"
        xStyl = ET.SubElement(self._xStyl, _mkTag("style", "style"), attrib=tAttr)

        tAttr = {}
        tAttr[_mkTag("style", "font-name")]   = self._textFont
        tAttr[_mkTag("fo",    "font-family")] = self._fontFamily
        tAttr[_mkTag("fo",    "font-size")]   = self._fSizeText
        ET.SubElement(xStyl, _mkTag("style", "text-properties"), attrib=tAttr)

        # Add Default Heading Style
        # =========================

        tAttr = {}
        tAttr[_mkTag("style", "name")]              = "Heading"
        tAttr[_mkTag("style", "family")]            = "paragraph"
        tAttr[_mkTag("style", "parent-style-name")] = "Standard"
        tAttr[_mkTag("style", "next-style-name")]   = "Text_20_body"
        tAttr[_mkTag("style", "class")]             = "text"
        xStyl = ET.SubElement(self._xStyl, _mkTag("style", "style"), attrib=tAttr)

        tAttr = {}
        tAttr[_mkTag("fo", "margin-top")]     = self._mTopHead
        tAttr[_mkTag("fo", "margin-bottom")]  = self._mBotHead
        tAttr[_mkTag("fo", "keep-with-next")] = "always"
        ET.SubElement(xStyl, _mkTag("style", "paragraph-properties"), attrib=tAttr)

        tAttr = {}
        tAttr[_mkTag("style", "font-name")]   = self._textFont
        tAttr[_mkTag("fo",    "font-family")] = self._fontFamily
        tAttr[_mkTag("fo",    "font-size")]   = self._fSizeHead
        ET.SubElement(xStyl, _mkTag("style", "text-properties"), attrib=tAttr)

        # Add Header and Footer Styles
        # ============================
        tAttr = {}
        tAttr[_mkTag("style", "name")]              = "Header_20_and_20_Footer"
        tAttr[_mkTag("style", "display-name")]      = "Header and Footer"
        tAttr[_mkTag("style", "family")]            = "paragraph"
        tAttr[_mkTag("style", "parent-style-name")] = "Standard"
        tAttr[_mkTag("style", "class")]             = "extra"
        ET.SubElement(self._xStyl, _mkTag("style", "style"), attrib=tAttr)

        return

    def _useableStyles(self):
        """Set the usable styles."""
        # Add Text Body Style
        # ===================

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Text body")
        oStyle.setParentStyleName("Standard")
        oStyle.setClass("text")
        oStyle.setMarginTop(self._mTopText)
        oStyle.setMarginBottom(self._mBotText)
        oStyle.setLineHeight(self._fLineHeight)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeText)
        oStyle.setTextAlign(self._textAlign)
        oStyle.packXML(self._xStyl, "Text_20_body")

        self._mainPara["Text_20_body"] = oStyle

        # Add Text Meta Style
        # ===================

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Text Meta")
        oStyle.setParentStyleName("Standard")
        oStyle.setClass("text")
        oStyle.setMarginTop(self._mTopMeta)
        oStyle.setMarginBottom(self._mBotMeta)
        oStyle.setLineHeight(self._fLineHeight)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeText)
        oStyle.setColor(self._colMetaTx)
        oStyle.setOpacity(self._opaMetaTx)
        oStyle.packXML(self._xStyl, "Text_20_Meta")

        self._mainPara["Text_20_Meta"] = oStyle

        # Add Title Style
        # ===============

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Title")
        oStyle.setParentStyleName("Heading")
        oStyle.setNextStyleName("Text_20_body")
        oStyle.setClass("chapter")
        oStyle.setTextAlign("center")
        oStyle.setMarginTop(self._mTopTitle)
        oStyle.setMarginBottom(self._mBotTitle)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeTitle)
        oStyle.setFontWeight("bold")
        oStyle.packXML(self._xStyl, "Title")

        self._mainPara["Title"] = oStyle

        # Add Separator Style
        # ===================

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Separator")
        oStyle.setParentStyleName("Standard")
        oStyle.setNextStyleName("Text_20_body")
        oStyle.setClass("text")
        oStyle.setTextAlign("center")
        oStyle.setMarginTop(self._mTopText)
        oStyle.setMarginBottom(self._mBotText)
        oStyle.setLineHeight(self._fLineHeight)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeText)
        oStyle.packXML(self._xStyl, "Separator")

        self._mainPara["Separator"] = oStyle

        # Add Heading 1 Style
        # ===================

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Heading 1")
        oStyle.setParentStyleName("Heading")
        oStyle.setNextStyleName("Text_20_body")
        oStyle.setOutlineLevel("1")
        oStyle.setClass("text")
        oStyle.setMarginTop(self._mTopHead1)
        oStyle.setMarginBottom(self._mBotHead1)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeHead1)
        oStyle.setColor(self._colHead12)
        oStyle.setOpacity(self._opaHead12)
        oStyle.setFontWeight("bold")
        oStyle.packXML(self._xStyl, "Heading_20_1")

        self._mainPara["Heading_20_1"] = oStyle

        # Add Heading 2 Style
        # ===================

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Heading 2")
        oStyle.setParentStyleName("Heading")
        oStyle.setNextStyleName("Text_20_body")
        oStyle.setOutlineLevel("2")
        oStyle.setClass("text")
        oStyle.setMarginTop(self._mTopHead2)
        oStyle.setMarginBottom(self._mBotHead2)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeHead2)
        oStyle.setColor(self._colHead12)
        oStyle.setOpacity(self._opaHead12)
        oStyle.setFontWeight("bold")
        oStyle.packXML(self._xStyl, "Heading_20_2")

        self._mainPara["Heading_20_2"] = oStyle

        # Add Heading 3 Style
        # ===================

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Heading 3")
        oStyle.setParentStyleName("Heading")
        oStyle.setNextStyleName("Text_20_body")
        oStyle.setOutlineLevel("3")
        oStyle.setClass("text")
        oStyle.setMarginTop(self._mTopHead3)
        oStyle.setMarginBottom(self._mBotHead3)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeHead3)
        oStyle.setColor(self._colHead34)
        oStyle.setOpacity(self._opaHead34)
        oStyle.setFontWeight("bold")
        oStyle.packXML(self._xStyl, "Heading_20_3")

        self._mainPara["Heading_20_3"] = oStyle

        # Add Heading 4 Style
        # ===================

        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Heading 4")
        oStyle.setParentStyleName("Heading")
        oStyle.setNextStyleName("Text_20_body")
        oStyle.setOutlineLevel("4")
        oStyle.setClass("text")
        oStyle.setMarginTop(self._mTopHead4)
        oStyle.setMarginBottom(self._mBotHead4)
        oStyle.setFontName(self._textFont)
        oStyle.setFontFamily(self._fontFamily)
        oStyle.setFontSize(self._fSizeHead4)
        oStyle.setColor(self._colHead34)
        oStyle.setOpacity(self._opaHead34)
        oStyle.setFontWeight("bold")
        oStyle.packXML(self._xStyl, "Heading_20_4")

        self._mainPara["Heading_20_4"] = oStyle

        # Add Header Style
        # ================
        oStyle = ODTParagraphStyle()
        oStyle.setDisplayName("Header")
        oStyle.setParentStyleName("Header_20_and_20_Footer")
        oStyle.setTextAlign("right")
        oStyle.packXML(self._xStyl, "Header")

        self._mainPara["Header"] = oStyle

        return

    def _writeHeader(self):
        """Write the header elements."""
        tAttr = {}
        tAttr[_mkTag("style", "name")]             = "Standard"
        tAttr[_mkTag("style", "page-layout-name")] = "PM1"
        xPage = ET.SubElement(self._xMast, _mkTag("style", "master-page"), attrib=tAttr)

        # Standard Page Header
        xHead = ET.SubElement(xPage, _mkTag("style", "header"))
        xPar = ET.SubElement(xHead, _mkTag("text", "p"), attrib={
            _mkTag("text", "style-name"): "Header"
        })
        xPar.text = self._headerText.strip() + " "

        xTail = ET.SubElement(xPar, _mkTag("text", "page-number"), attrib={
            _mkTag("text", "select-page"): "current"
        })
        xTail.text = "2"
        xTail.tail = ""  # Prevent line break in indented XML

        # First Page Header
        xHead = ET.SubElement(xPage, _mkTag("style", "header-first"))
        xPar = ET.SubElement(xHead, _mkTag("text", "p"), attrib={
            _mkTag("text", "style-name"): "Header"
        })

        return

# END Class ToOdt


# =============================================================================================== #
#  Auto-Style Classes
# =============================================================================================== #

class ODTParagraphStyle:
    """Wrapper class for the paragraph style setting used by the
    exporter. Only the used settings are exposed here to keep the class
    minimal and fast.
    """
    VALID_ALIGN  = ["start", "center", "end", "justify", "inside", "outside", "left", "right"]
    VALID_BREAK  = ["auto", "column", "page", "even-page", "odd-page", "inherit"]
    VALID_LEVEL  = ["1", "2", "3", "4"]
    VALID_CLASS  = ["text", "chapter"]
    VALID_WEIGHT = ["normal", "inherit", "bold"]

    def __init__(self):

        # Attributes
        self._mAttr = {
            "display-name":          ["style", None],
            "parent-style-name":     ["style", None],
            "next-style-name":       ["style", None],
            "default-outline-level": ["style", None],
            "class":                 ["style", None],
        }

        # Paragraph Attributes
        self._pAttr = {
            "margin-top":    ["fo", None],
            "margin-bottom": ["fo", None],
            "margin-left":   ["fo", None],
            "margin-right":  ["fo", None],
            "line-height":   ["fo", None],
            "text-align":    ["fo", None],
            "break-before":  ["fo", None],
            "break-after":   ["fo", None],
        }

        # Text Attributes
        self._tAttr = {
            "font-name":   ["style", None],
            "font-family": ["fo",    None],
            "font-size":   ["fo",    None],
            "font-weight": ["fo",    None],
            "color":       ["fo",    None],
            "opacity":     ["loext", None],
        }

        return

    ##
    #  Attribute Setters
    ##

    def setDisplayName(self, value: str | None):
        self._mAttr["display-name"][1] = value
        return

    def setParentStyleName(self, value: str | None):
        self._mAttr["parent-style-name"][1] = value
        return

    def setNextStyleName(self, value: str | None):
        self._mAttr["next-style-name"][1] = value
        return

    def setOutlineLevel(self, value: str | None):
        if value in self.VALID_LEVEL:
            self._mAttr["default-outline-level"][1] = value
        else:
            self._mAttr["default-outline-level"][1] = None
        return

    def setClass(self, value: str | None):
        if value in self.VALID_CLASS:
            self._mAttr["class"][1] = value
        else:
            self._mAttr["class"][1] = None
        return

    ##
    #  Paragraph Setters
    ##

    def setMarginTop(self, value: str | None):
        self._pAttr["margin-top"][1] = value
        return

    def setMarginBottom(self, value: str | None):
        self._pAttr["margin-bottom"][1] = value
        return

    def setMarginLeft(self, value: str | None):
        self._pAttr["margin-left"][1] = value
        return

    def setMarginRight(self, value: str | None):
        self._pAttr["margin-right"][1] = value
        return

    def setLineHeight(self, value: str | None):
        self._pAttr["line-height"][1] = value
        return

    def setTextAlign(self, value: str | None):
        if value in self.VALID_ALIGN:
            self._pAttr["text-align"][1] = value
        else:
            self._pAttr["text-align"][1] = None
        return

    def setBreakBefore(self, value: str | None):
        if value in self.VALID_BREAK:
            self._pAttr["break-before"][1] = value
        else:
            self._pAttr["break-before"][1] = None
        return

    def setBreakAfter(self, value: str | None):
        if value in self.VALID_BREAK:
            self._pAttr["break-after"][1] = value
        else:
            self._pAttr["break-after"][1] = None
        return

    ##
    #  Text Setters
    ##

    def setFontName(self, value: str | None):
        self._tAttr["font-name"][1] = value
        return

    def setFontFamily(self, value: str | None):
        self._tAttr["font-family"][1] = value
        return

    def setFontSize(self, value: str | None):
        self._tAttr["font-size"][1] = value
        return

    def setFontWeight(self, value: str | None):
        if value in self.VALID_WEIGHT:
            self._tAttr["font-weight"][1] = value
        else:
            self._tAttr["font-weight"][1] = None
        return

    def setColor(self, value: str | None):
        self._tAttr["color"][1] = value
        return

    def setOpacity(self, value: str | None):
        self._tAttr["opacity"][1] = value
        return

    ##
    #  Methods
    ##

    def checkNew(self, refStyle: ODTParagraphStyle):
        """Check if there are new settings in refStyle that differ from
        those in the current object.
        """
        for aName, (_, aVal) in refStyle._mAttr.items():
            if aVal is not None and aVal != self._mAttr[aName][1]:
                return True
        for aName, (_, aVal) in refStyle._pAttr.items():
            if aVal is not None and aVal != self._pAttr[aName][1]:
                return True
        for aName, (_, aVal) in refStyle._tAttr.items():
            if aVal is not None and aVal != self._tAttr[aName][1]:
                return True
        return False

    def getID(self) -> str:
        """Generate a unique ID from the settings."""
        theString = (
            f"Paragraph:Main:{str(self._mAttr)}:"
            f"Paragraph:Para:{str(self._pAttr)}:"
            f"Paragraph:Text:{str(self._tAttr)}:"
        )
        return sha256(theString.encode()).hexdigest()

    def packXML(self, xParent: ET.Element, name: str):
        """Pack the content into an xml element."""
        theAttr = {}
        theAttr[_mkTag("style", "name")] = name
        theAttr[_mkTag("style", "family")] = "paragraph"
        for aName, (aNm, aVal) in self._mAttr.items():
            if aVal is not None:
                theAttr[_mkTag(aNm, aName)] = aVal

        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=theAttr)

        theAttr = {}
        for aName, (aNm, aVal) in self._pAttr.items():
            if aVal is not None:
                theAttr[_mkTag(aNm, aName)] = aVal

        if theAttr:
            ET.SubElement(xEntry, _mkTag("style", "paragraph-properties"), attrib=theAttr)

        theAttr = {}
        for aName, (aNm, aVal) in self._tAttr.items():
            if aVal is not None:
                theAttr[_mkTag(aNm, aName)] = aVal

        if theAttr:
            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=theAttr)

        return

# END Class ODTParagraphStyle


class ODTTextStyle:
    """Wrapper class for the text style setting used by the exporter.
    Only the used settings are exposed here to keep the class minimal
    and fast.
    """
    VALID_WEIGHT = ["normal", "inherit", "bold"]
    VALID_STYLE  = ["normal", "inherit", "italic"]
    VALID_LSTYLE = ["none", "solid"]
    VALID_LTYPE  = ["none", "single", "double"]

    def __init__(self):

        # Text Attributes
        self._tAttr = {
            "font-weight":             ["fo",    None],
            "font-style":              ["fo",    None],
            "text-line-through-style": ["style", None],
            "text-line-through-type":  ["style", None],
        }

        return

    ##
    #  Setters
    ##

    def setFontWeight(self, value: str | None):
        if value in self.VALID_WEIGHT:
            self._tAttr["font-weight"][1] = value
        else:
            self._tAttr["font-weight"][1] = None
        return

    def setFontStyle(self, value: str | None):
        if value in self.VALID_STYLE:
            self._tAttr["font-style"][1] = value
        else:
            self._tAttr["font-style"][1] = None
        return

    def setStrikeStyle(self, value: str | None):
        if value in self.VALID_LSTYLE:
            self._tAttr["text-line-through-style"][1] = value
        else:
            self._tAttr["text-line-through-style"][1] = None
        return

    def setStrikeType(self, value: str | None):
        if value in self.VALID_LTYPE:
            self._tAttr["text-line-through-type"][1] = value
        else:
            self._tAttr["text-line-through-type"][1] = None
        return

    ##
    #  Methods
    ##

    def packXML(self, xParent: ET.Element, name: str):
        """Pack the content into an xml element."""
        theAttr = {}
        theAttr[_mkTag("style", "name")] = name
        theAttr[_mkTag("style", "family")] = "text"
        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=theAttr)

        theAttr = {}
        for aName, (aNm, aVal) in self._tAttr.items():
            if aVal is not None:
                theAttr[_mkTag(aNm, aName)] = aVal

        if theAttr:
            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=theAttr)

        return

# END Class ODTTextStyle


# =============================================================================================== #
#  XML Complex Element Helper Class
# =============================================================================================== #

X_ROOT_TEXT = 0
X_ROOT_TAIL = 1
X_SPAN_TEXT = 2
X_SPAN_SING = 3


class XMLParagraph:
    """This is a helper class to manage the text content of a single
    XML element using mixed content tags.

    Rules:
     * The root tag can only have text set, never tail.
     * Any span must be under root, and the text in the span is set in
       one pass. The span then becomes the new base element using tail
       for further added text, permanently replacing root.
     * Any single special tags like tabs, line breaks or multi-spaces,
       should never have text set. After insertion, they become the next
       tail tag if on root level, or if in a span, only exists within
       the lifetime of the span. In this case, the span becomes the new
       tail.

    The four constants associated with this class represent the only
    allowed states the class can exist in, which dictates which XML
    object and attribute is written to,
    """

    def __init__(self, xRoot: ET.Element):

        self._xRoot = xRoot
        self._xTail = ET.Element("")
        self._xSing = ET.Element("")

        self._nState = X_ROOT_TEXT
        self._chrPos = 0
        self._rawTxt = ""
        self._xRoot.text = ""

        return

    def appendText(self, tText: str):
        """Append text to the XML element. We do this one character at
        the time in order to be able to process line breaks, tabs and
        spaces separately. Multiple spaces are concatenated into a
        single tag, and must therefore be processed separately.
        """
        tText = stripEscape(tText)
        nSpaces = 0
        self._rawTxt += tText

        for c in tText:
            if c == " ":
                nSpaces += 1
                continue

            elif nSpaces > 0:
                self._processSpaces(nSpaces)
                nSpaces = 0

            if c == "\n":
                if self._nState in (X_ROOT_TEXT, X_ROOT_TAIL):
                    self._xTail = ET.SubElement(self._xRoot, TAG_BR)
                    self._xTail.tail = ""
                    self._nState = X_ROOT_TAIL
                    self._chrPos += 1

                elif self._nState in (X_SPAN_TEXT, X_SPAN_SING):
                    self._xSing = ET.SubElement(self._xTail, TAG_BR)
                    self._xSing.tail = ""
                    self._nState = X_SPAN_SING
                    self._chrPos += 1

            elif c == "\t":
                if self._nState in (X_ROOT_TEXT, X_ROOT_TAIL):
                    self._xTail = ET.SubElement(self._xRoot, TAG_TAB)
                    self._xTail.tail = ""
                    self._nState = X_ROOT_TAIL
                    self._chrPos += 1

                elif self._nState in (X_SPAN_TEXT, X_SPAN_SING):
                    self._xSing = ET.SubElement(self._xTail, TAG_TAB)
                    self._xSing.tail = ""
                    self._chrPos += 1
                    self._nState = X_SPAN_SING

            else:
                if self._nState == X_ROOT_TEXT:
                    self._xRoot.text = (self._xRoot.text or "") + c
                    self._chrPos += 1
                elif self._nState == X_ROOT_TAIL:
                    self._xTail.tail = (self._xTail.tail or "") + c
                    self._chrPos += 1
                elif self._nState == X_SPAN_TEXT:
                    self._xTail.text = (self._xTail.text or "") + c
                    self._chrPos += 1
                elif self._nState == X_SPAN_SING:
                    self._xSing.tail = (self._xSing.tail or "") + c
                    self._chrPos += 1

        if nSpaces > 0:
            # Handle trailing spaces
            self._processSpaces(nSpaces)

        return

    def appendSpan(self, tText: str, tFmt: str):
        """Append a text span to the XML element. The span is always
        closed since we do not allow nested spans (like Libre Office).
        Therefore we return to the root element level when we're done
        processing the text of the span.
        """
        self._xTail = ET.SubElement(self._xRoot, TAG_SPAN, attrib={TAG_STNM: tFmt})
        self._xTail.text = ""  # Defaults to None
        self._xTail.tail = ""  # Defaults to None
        self._nState = X_SPAN_TEXT
        self.appendText(tText)
        self._nState = X_ROOT_TAIL
        return

    def checkError(self):
        """Check that the number of characters written matches the
        number of characters received.
        """
        errMsg = ""
        nMissed = len(self._rawTxt) - self._chrPos
        if nMissed != 0:
            errMsg = "%d char(s) were not written: '%s'" % (nMissed, self._rawTxt)
        return nMissed, errMsg

    ##
    #  Internal Functions
    ##

    def _processSpaces(self, nSpaces: int):
        """Add spaces to paragraph. The first space is always written
        as-is (unless it's the first character of the paragraph). The
        second space uses the dedicated tag for spaces, and from the
        third space and on, a counter is added to the tag.

        See: http://docs.oasis-open.org/office/v1.2/os/OpenDocument-v1.2-os-part1.html
        Sections: 6.1.2, 6.1.3, and 19.763
        """
        if nSpaces > 0:
            if self._chrPos > 0:
                if self._nState == X_ROOT_TEXT:
                    self._xRoot.text = (self._xRoot.text or "") + " "
                    self._chrPos += 1
                elif self._nState == X_ROOT_TAIL:
                    self._xTail.tail = (self._xTail.tail or "") + " "
                    self._chrPos += 1
                elif self._nState == X_SPAN_TEXT:
                    self._xTail.text = (self._xTail.text or "") + " "
                    self._chrPos += 1
                elif self._nState == X_SPAN_SING:
                    self._xSing.tail = (self._xSing.tail or "") + " "
                    self._chrPos += 1
            else:
                nSpaces += 1

        if nSpaces == 2:
            if self._nState in (X_ROOT_TEXT, X_ROOT_TAIL):
                self._xTail = ET.SubElement(self._xRoot, TAG_SPC)
                self._xTail.tail = ""
                self._nState = X_ROOT_TAIL
                self._chrPos += nSpaces - 1

            elif self._nState in (X_SPAN_TEXT, X_SPAN_SING):
                self._xSing = ET.SubElement(self._xTail, TAG_SPC)
                self._xSing.tail = ""
                self._nState = X_SPAN_SING
                self._chrPos += nSpaces - 1

        elif nSpaces > 2:
            if self._nState in (X_ROOT_TEXT, X_ROOT_TAIL):
                self._xTail = ET.SubElement(self._xRoot, TAG_SPC, attrib={
                    TAG_NSPC: str(nSpaces - 1)
                })
                self._xTail.tail = ""
                self._nState = X_ROOT_TAIL
                self._chrPos += nSpaces - 1

            elif self._nState in (X_SPAN_TEXT, X_SPAN_SING):
                self._xSing = ET.SubElement(self._xTail, TAG_SPC, attrib={
                    TAG_NSPC: str(nSpaces - 1)
                })
                self._xSing.tail = ""
                self._nState = X_SPAN_SING
                self._chrPos += nSpaces - 1

        return

# END Class XMLParagraph
