from fontTools.misc.py23 import *
from fontTools.misc.testTools import parseXML, getXML
from fontTools.misc.textTools import deHexStr
from fontTools.ttLib import TTFont, newTable, TTLibError
from fontTools.misc.loggingTools import CapturingLogHandler
from fontTools.ttLib.tables._h_m_t_x import table__h_m_t_x, log
import struct
import unittest


class HmtxTableTest(unittest.TestCase):

    def __init__(self, methodName):
        unittest.TestCase.__init__(self, methodName)
        # Python 3 renamed assertRaisesRegexp to assertRaisesRegex,
        # and fires deprecation warnings if a program uses the old name.
        if not hasattr(self, "assertRaisesRegex"):
            self.assertRaisesRegex = self.assertRaisesRegexp

    @classmethod
    def setUpClass(cls):
        cls.tableClass = table__h_m_t_x
        cls.tag = "hmtx"

    def makeFont(self, numGlyphs, numberOfMetrics):
        font = TTFont()
        maxp = font['maxp'] = newTable('maxp')
        maxp.numGlyphs = numGlyphs
        # from A to ...
        font.glyphOrder = [chr(i) for i in range(65, 65+numGlyphs)]
        headerTag = self.tableClass.headerTag
        font[headerTag] = newTable(headerTag)
        numberOfMetricsName = self.tableClass.numberOfMetricsName
        setattr(font[headerTag], numberOfMetricsName, numberOfMetrics)
        return font

    def test_decompile(self):
        font = self.makeFont(numGlyphs=3, numberOfMetrics=3)
        data = deHexStr("02A2 FFF5 0278 004F 02C6 0036")

        mtxTable = newTable(self.tag)
        mtxTable.decompile(data, font)

        self.assertEqual(mtxTable['A'], (674, -11))
        self.assertEqual(mtxTable['B'], (632, 79))
        self.assertEqual(mtxTable['C'], (710, 54))

    def test_decompile_additional_SB(self):
        font = self.makeFont(numGlyphs=4, numberOfMetrics=2)
        metrics = deHexStr("02A2 FFF5 0278 004F")
        extraSideBearings = deHexStr("0036 FFFC")
        data = metrics + extraSideBearings

        mtxTable = newTable(self.tag)
        mtxTable.decompile(data, font)

        self.assertEqual(mtxTable['A'], (674, -11))
        self.assertEqual(mtxTable['B'], (632, 79))
        # all following have same width as the previous
        self.assertEqual(mtxTable['C'], (632, 54))
        self.assertEqual(mtxTable['D'], (632, -4))

    def test_decompile_not_enough_data(self):
        font = self.makeFont(numGlyphs=1, numberOfMetrics=1)
        mtxTable = newTable(self.tag)
        msg = "not enough '%s' table data" % self.tag

        with self.assertRaisesRegex(TTLibError, msg):
            mtxTable.decompile(b"\0\0\0", font)

    def test_decompile_too_much_data(self):
        font = self.makeFont(numGlyphs=1, numberOfMetrics=1)
        mtxTable = newTable(self.tag)
        msg = "too much '%s' table data" % self.tag

        with CapturingLogHandler(log, "WARNING") as captor:
            mtxTable.decompile(b"\0\0\0\0\0", font)

        self.assertTrue(
            len([r for r in captor.records if msg == r.msg]) == 1)

    def test_decompile_num_metrics_greater_than_glyphs(self):
        font = self.makeFont(numGlyphs=1, numberOfMetrics=2)
        mtxTable = newTable(self.tag)
        msg = "The %s.%s exceeds the maxp.numGlyphs" % (
            self.tableClass.headerTag, self.tableClass.numberOfMetricsName)

        with CapturingLogHandler(log, "WARNING") as captor:
            mtxTable.decompile(b"\0\0\0\0", font)

        self.assertTrue(
            len([r for r in captor.records if msg == r.msg]) == 1)

    def test_decompile_possibly_negative_advance(self):
        font = self.makeFont(numGlyphs=1, numberOfMetrics=1)
        # we warn if advance is > 0x7FFF as it might be interpreted as signed
        # by some authoring tools
        data = deHexStr("8000 0000")
        mtxTable = newTable(self.tag)

        with CapturingLogHandler(log, "WARNING") as captor:
            mtxTable.decompile(data, font)

        self.assertTrue(
            len([r for r in captor.records
                if "has a huge advance" in r.msg]) == 1)

    def test_decompile_no_header_table(self):
        font = TTFont()
        maxp = font['maxp'] = newTable('maxp')
        maxp.numGlyphs = 3
        font.glyphOrder = ["A", "B", "C"]

        self.assertNotIn(self.tableClass.headerTag, font)

        data = deHexStr("0190 001E 0190 0028 0190 0032")
        mtxTable = newTable(self.tag)
        mtxTable.decompile(data, font)

        self.assertEqual(
            mtxTable.metrics,
            {
                "A": (400, 30),
                "B": (400, 40),
                "C": (400, 50),
            }
        )

    def test_compile(self):
        # we set the wrong 'numberOfMetrics' to check it gets adjusted
        font = self.makeFont(numGlyphs=3, numberOfMetrics=4)
        mtxTable = font[self.tag] = newTable(self.tag)
        mtxTable.metrics = {
            'A': (674, -11),
            'B': (632, 79),
            'C': (710, 54),
        }

        data = mtxTable.compile(font)

        self.assertEqual(data, deHexStr("02A2 FFF5 0278 004F 02C6 0036"))

        headerTable = font[self.tableClass.headerTag]
        self.assertEqual(
            getattr(headerTable, self.tableClass.numberOfMetricsName), 3)

    def test_compile_additional_SB(self):
        font = self.makeFont(numGlyphs=4, numberOfMetrics=1)
        mtxTable = font[self.tag] = newTable(self.tag)
        mtxTable.metrics = {
            'A': (632, -11),
            'B': (632, 79),
            'C': (632, 54),
            'D': (632, -4),
        }

        data = mtxTable.compile(font)

        self.assertEqual(data, deHexStr("0278 FFF5 004F 0036 FFFC"))

    def test_compile_negative_advance(self):
        font = self.makeFont(numGlyphs=1, numberOfMetrics=1)
        mtxTable = font[self.tag] = newTable(self.tag)
        mtxTable.metrics = {'A': [-1, 0]}

        with CapturingLogHandler(log, "ERROR") as captor:
            with self.assertRaisesRegex(TTLibError, "negative advance"):
                mtxTable.compile(font)

        self.assertTrue(
            len([r for r in captor.records
                if "Glyph 'A' has negative advance" in r.msg]) == 1)

    def test_compile_struct_out_of_range(self):
        font = self.makeFont(numGlyphs=1, numberOfMetrics=1)
        mtxTable = font[self.tag] = newTable(self.tag)
        mtxTable.metrics = {'A': (0xFFFF+1, -0x8001)}

        with self.assertRaises(struct.error):
            mtxTable.compile(font)

    def test_compile_round_float_values(self):
        font = self.makeFont(numGlyphs=3, numberOfMetrics=2)
        mtxTable = font[self.tag] = newTable(self.tag)
        mtxTable.metrics = {
            'A': (0.5, 0.5),  # round -> (1, 1)
            'B': (0.1, 0.9),  # round -> (0, 1)
            'C': (0.1, 0.1),  # round -> (0, 0)
        }

        data = mtxTable.compile(font)

        self.assertEqual(data, deHexStr("0001 0001 0000 0001 0000"))

    def test_compile_no_header_table(self):
        font = TTFont()
        maxp = font['maxp'] = newTable('maxp')
        maxp.numGlyphs = 3
        font.glyphOrder = [chr(i) for i in range(65, 68)]
        mtxTable = font[self.tag] = newTable(self.tag)
        mtxTable.metrics = {
            "A": (400, 30),
            "B": (400, 40),
            "C": (400, 50),
        }

        self.assertNotIn(self.tableClass.headerTag, font)

        data = mtxTable.compile(font)

        self.assertEqual(data, deHexStr("0190 001E 0190 0028 0190 0032"))

    def test_toXML(self):
        font = self.makeFont(numGlyphs=2, numberOfMetrics=2)
        mtxTable = font[self.tag] = newTable(self.tag)
        mtxTable.metrics = {'B': (632, 79), 'A': (674, -11)}

        self.assertEqual(
            getXML(mtxTable.toXML),
            ('<mtx name="A" %s="674" %s="-11"/>\n'
             '<mtx name="B" %s="632" %s="79"/>' % (
                (self.tableClass.advanceName,
                 self.tableClass.sideBearingName) * 2)).split('\n'))

    def test_fromXML(self):
        mtxTable = newTable(self.tag)

        for name, attrs, content in parseXML(
                '<mtx name="A" %s="674" %s="-11"/>'
                '<mtx name="B" %s="632" %s="79"/>' % (
                    (self.tableClass.advanceName,
                     self.tableClass.sideBearingName) * 2)):
            mtxTable.fromXML(name, attrs, content, ttFont=None)

        self.assertEqual(
            mtxTable.metrics, {'A': (674, -11), 'B': (632, 79)})

    def test_delitem(self):
        mtxTable = newTable(self.tag)
        mtxTable.metrics = {'A': (0, 0)}

        del mtxTable['A']

        self.assertTrue('A' not in mtxTable.metrics)

    def test_setitem(self):
        mtxTable = newTable(self.tag)
        mtxTable.metrics = {'A': (674, -11), 'B': (632, 79)}
        mtxTable['B'] = [0, 0]  # list is converted to tuple

        self.assertEqual(mtxTable.metrics, {'A': (674, -11), 'B': (0, 0)})


if __name__ == "__main__":
    import sys
    sys.exit(unittest.main())
