from io import BytesIO
import os
import unittest
from fontTools.ttLib import TTFont
from fontTools.misc.textTools import strjoin
from fontTools.misc.xmlReader import XMLReader, ProgressPrinter, BUFSIZE
import tempfile


class TestXMLReader(unittest.TestCase):
    def test_decode_utf8(self):
        class DebugXMLReader(XMLReader):
            def __init__(self, fileOrPath, ttFont, progress=None):
                super(DebugXMLReader, self).__init__(fileOrPath, ttFont, progress)
                self.contents = []

            def _endElementHandler(self, name):
                if self.stackSize == 3:
                    name, attrs, content = self.root
                    self.contents.append(content)
                super(DebugXMLReader, self)._endElementHandler(name)

        expected = "fôôbär"
        data = (
            """\
<?xml version="1.0" encoding="UTF-8"?>
<ttFont>
  <name>
    <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
      %s
    </namerecord>
  </name>
</ttFont>
"""
            % expected
        )

        with BytesIO(data.encode("utf-8")) as tmp:
            reader = DebugXMLReader(tmp, TTFont())
            reader.read()
        content = strjoin(reader.contents[0]).strip()
        self.assertEqual(expected, content)

    def test_normalise_newlines(self):
        class DebugXMLReader(XMLReader):
            def __init__(self, fileOrPath, ttFont, progress=None):
                super(DebugXMLReader, self).__init__(fileOrPath, ttFont, progress)
                self.newlines = []

            def _characterDataHandler(self, data):
                self.newlines.extend([c for c in data if c in ("\r", "\n")])

        # notice how when CR is escaped, it is not normalised by the XML parser
        data = (
            "<ttFont>\r"  #        \r -> \n
            "  <test>\r\n"  #      \r\n -> \n
            "    a line of text\n"  #              \n
            "    escaped CR and unix newline &#13;\n"  #   &#13;\n -> \r\n
            "    escaped CR and macintosh newline &#13;\r"  #   &#13;\r -> \r\n
            "    escaped CR and windows newline &#13;\r\n"  # &#13;\r\n -> \r\n
            "  </test>\n"  #              \n
            "</ttFont>"
        )

        with BytesIO(data.encode("utf-8")) as tmp:
            reader = DebugXMLReader(tmp, TTFont())
            reader.read()
        expected = ["\n"] * 3 + ["\r", "\n"] * 3 + ["\n"]
        self.assertEqual(expected, reader.newlines)

    def test_progress(self):
        class DummyProgressPrinter(ProgressPrinter):
            def __init__(self, title, maxval=100):
                self.label = title
                self.maxval = maxval
                self.pos = 0

            def set(self, val, maxval=None):
                if maxval is not None:
                    self.maxval = maxval
                self.pos = val

            def increment(self, val=1):
                self.pos += val

            def setLabel(self, text):
                self.label = text

        data = (
            "<ttFont>\n"
            "  <test>\n"
            "    %s\n"
            "  </test>\n"
            "</ttFont>\n" % ("z" * 2 * BUFSIZE)
        ).encode("utf-8")

        dataSize = len(data)
        progressBar = DummyProgressPrinter("test")
        with BytesIO(data) as tmp:
            reader = XMLReader(tmp, TTFont(), progress=progressBar)
            self.assertEqual(progressBar.pos, 0)
            reader.read()
        self.assertEqual(progressBar.pos, dataSize // 100)
        self.assertEqual(progressBar.maxval, dataSize // 100)
        self.assertTrue("test" in progressBar.label)
        with BytesIO(b"<ttFont></ttFont>") as tmp:
            reader = XMLReader(tmp, TTFont(), progress=progressBar)
            reader.read()
        # when data size is less than 100 bytes, 'maxval' is 1
        self.assertEqual(progressBar.maxval, 1)

    def test_close_file_path(self):
        with tempfile.NamedTemporaryFile(delete=False) as tmp:
            tmp.write(b"<ttFont></ttFont>")
        reader = XMLReader(tmp.name, TTFont())
        reader.read()
        # when reading from path, the file is closed automatically at the end
        self.assertTrue(reader.file.closed)
        # this does nothing
        reader.close()
        self.assertTrue(reader.file.closed)
        os.remove(tmp.name)

    def test_close_file_obj(self):
        with tempfile.NamedTemporaryFile(delete=False) as tmp:
            tmp.write(b'<ttFont>"hello"</ttFont>')
        with open(tmp.name, "rb") as f:
            reader = XMLReader(f, TTFont())
            reader.read()
            # when reading from a file or file-like object, the latter is kept open
            self.assertFalse(reader.file.closed)
        # ... until the user explicitly closes it
        reader.close()
        self.assertTrue(reader.file.closed)
        os.remove(tmp.name)

    def test_read_sub_file(self):
        # Verifies that sub-file content is able to be read to a table.
        expectedContent = "testContent"
        expectedNameID = "1"
        expectedPlatform = "3"
        expectedLangId = "0x409"

        with tempfile.NamedTemporaryFile(delete=False) as tmp:
            subFileData = (
                '<ttFont ttLibVersion="3.15">'
                "<name>"
                '<namerecord nameID="%s" platformID="%s" platEncID="1" langID="%s">'
                "%s"
                "</namerecord>"
                "</name>"
                "</ttFont>"
            ) % (expectedNameID, expectedPlatform, expectedLangId, expectedContent)
            tmp.write(subFileData.encode("utf-8"))

        with tempfile.NamedTemporaryFile(delete=False) as tmp2:
            fileData = (
                '<ttFont ttLibVersion="3.15">'
                "<name>"
                '<namerecord src="%s"/>'
                "</name>"
                "</ttFont>"
            ) % tmp.name
            tmp2.write(fileData.encode("utf-8"))

        ttf = TTFont()
        with open(tmp2.name, "rb") as f:
            reader = XMLReader(f, ttf)
            reader.read()
            reader.close()
            nameTable = ttf["name"]
            self.assertTrue(int(expectedNameID) == nameTable.names[0].nameID)
            self.assertTrue(int(expectedLangId, 16) == nameTable.names[0].langID)
            self.assertTrue(int(expectedPlatform) == nameTable.names[0].platformID)
            self.assertEqual(
                expectedContent,
                nameTable.names[0].string.decode(nameTable.names[0].getEncoding()),
            )

        os.remove(tmp.name)
        os.remove(tmp2.name)


if __name__ == "__main__":
    import sys

    sys.exit(unittest.main())