from fontTools.misc.loggingTools import CapturingLogHandler
from fontTools.misc.testTools import parseXML, getXML
from fontTools.misc.textTools import deHexStr
from fontTools.ttLib import TTFont, newTable
from fontTools.misc.fixedTools import log
import os
import unittest


CURR_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
DATA_DIR = os.path.join(CURR_DIR, 'data')

VHEA_DATA_VERSION_11 = deHexStr(
    '0001 1000 '  # 1.1   version
    '01F4 '       # 500   ascent
    'FE0C '       # -500  descent
    '0000 '       # 0     lineGap
    '0BB8 '       # 3000  advanceHeightMax
    'FC16 '       # -1002 minTopSideBearing
    'FD5B '       # -677  minBottomSideBearing
    '0B70 '       # 2928  yMaxExtent
    '0000 '       # 0     caretSlopeRise
    '0001 '       # 1     caretSlopeRun
    '0000 '       # 0     caretOffset
    '0000 '       # 0     reserved1
    '0000 '       # 0     reserved2
    '0000 '       # 0     reserved3
    '0000 '       # 0     reserved4
    '0000 '       # 0     metricDataFormat
    '000C '       # 12    numberOfVMetrics
)

VHEA_DATA_VERSION_10 = deHexStr('00010000') + VHEA_DATA_VERSION_11[4:]

VHEA_VERSION_11_AS_DICT = {
    'tableTag': 'vhea',
    'tableVersion': 0x00011000,
    'ascent': 500,
    'descent': -500,
    'lineGap': 0,
    'advanceHeightMax': 3000,
    'minTopSideBearing': -1002,
    'minBottomSideBearing': -677,
    'yMaxExtent': 2928,
    'caretSlopeRise': 0,
    'caretSlopeRun': 1,
    'caretOffset': 0,
    'reserved1': 0,
    'reserved2': 0,
    'reserved3': 0,
    'reserved4': 0,
    'metricDataFormat': 0,
    'numberOfVMetrics': 12,
}

VHEA_VERSION_10_AS_DICT = dict(VHEA_VERSION_11_AS_DICT)
VHEA_VERSION_10_AS_DICT['tableVersion'] = 0x00010000

VHEA_XML_VERSION_11 = [
    '<tableVersion value="0x00011000"/>',
    '<ascent value="500"/>',
    '<descent value="-500"/>',
    '<lineGap value="0"/>',
    '<advanceHeightMax value="3000"/>',
    '<minTopSideBearing value="-1002"/>',
    '<minBottomSideBearing value="-677"/>',
    '<yMaxExtent value="2928"/>',
    '<caretSlopeRise value="0"/>',
    '<caretSlopeRun value="1"/>',
    '<caretOffset value="0"/>',
    '<reserved1 value="0"/>',
    '<reserved2 value="0"/>',
    '<reserved3 value="0"/>',
    '<reserved4 value="0"/>',
    '<metricDataFormat value="0"/>',
    '<numberOfVMetrics value="12"/>',
]

VHEA_XML_VERSION_11_AS_FLOAT = [
    '<tableVersion value="1.0625"/>',
] + VHEA_XML_VERSION_11[1:]

VHEA_XML_VERSION_10 = [
    '<tableVersion value="0x00010000"/>',
] + VHEA_XML_VERSION_11[1:]

VHEA_XML_VERSION_10_AS_FLOAT = [
    '<tableVersion value="1.0"/>',
] + VHEA_XML_VERSION_11[1:]


class VheaCompileOrToXMLTest(unittest.TestCase):

    def setUp(self):
        vhea = newTable('vhea')
        vhea.tableVersion = 0x00010000
        vhea.ascent = 500
        vhea.descent = -500
        vhea.lineGap = 0
        vhea.advanceHeightMax = 3000
        vhea.minTopSideBearing = -1002
        vhea.minBottomSideBearing = -677
        vhea.yMaxExtent = 2928
        vhea.caretSlopeRise = 0
        vhea.caretSlopeRun = 1
        vhea.caretOffset = 0
        vhea.metricDataFormat = 0
        vhea.numberOfVMetrics = 12
        vhea.reserved1 = vhea.reserved2 = vhea.reserved3 = vhea.reserved4 = 0
        self.font = TTFont(sfntVersion='OTTO')
        self.font['vhea'] = vhea

    def test_compile_caretOffset_as_reserved0(self):
        vhea = self.font['vhea']
        del vhea.caretOffset
        vhea.reserved0 = 0
        self.assertEqual(VHEA_DATA_VERSION_10, vhea.compile(self.font))

    def test_compile_version_10(self):
        vhea = self.font['vhea']
        vhea.tableVersion = 0x00010000
        self.assertEqual(VHEA_DATA_VERSION_10, vhea.compile(self.font))

    def test_compile_version_10_as_float(self):
        vhea = self.font['vhea']
        vhea.tableVersion = 1.0
        with CapturingLogHandler(log, "WARNING") as captor:
            self.assertEqual(VHEA_DATA_VERSION_10, vhea.compile(self.font))
        self.assertTrue(
            len([r for r in captor.records
                 if "Table version value is a float" in r.msg]) == 1)

    def test_compile_version_11(self):
        vhea = self.font['vhea']
        vhea.tableVersion = 0x00011000
        self.assertEqual(VHEA_DATA_VERSION_11, vhea.compile(self.font))

    def test_compile_version_11_as_float(self):
        vhea = self.font['vhea']
        vhea.tableVersion = 1.0625
        with CapturingLogHandler(log, "WARNING") as captor:
            self.assertEqual(VHEA_DATA_VERSION_11, vhea.compile(self.font))
        self.assertTrue(
            len([r for r in captor.records
                 if "Table version value is a float" in r.msg]) == 1)

    def test_toXML_caretOffset_as_reserved0(self):
        vhea = self.font['vhea']
        del vhea.caretOffset
        vhea.reserved0 = 0
        self.assertEqual(getXML(vhea.toXML), VHEA_XML_VERSION_10)

    def test_toXML_version_10(self):
        vhea = self.font['vhea']
        self.font['vhea'].tableVersion = 0x00010000
        self.assertEqual(getXML(vhea.toXML), VHEA_XML_VERSION_10)

    def test_toXML_version_10_as_float(self):
        vhea = self.font['vhea']
        vhea.tableVersion = 1.0
        with CapturingLogHandler(log, "WARNING") as captor:
            self.assertEqual(getXML(vhea.toXML), VHEA_XML_VERSION_10)
        self.assertTrue(
            len([r for r in captor.records
                 if "Table version value is a float" in r.msg]) == 1)

    def test_toXML_version_11(self):
        vhea = self.font['vhea']
        self.font['vhea'].tableVersion = 0x00011000
        self.assertEqual(getXML(vhea.toXML), VHEA_XML_VERSION_11)

    def test_toXML_version_11_as_float(self):
        vhea = self.font['vhea']
        vhea.tableVersion = 1.0625
        with CapturingLogHandler(log, "WARNING") as captor:
            self.assertEqual(getXML(vhea.toXML), VHEA_XML_VERSION_11)
        self.assertTrue(
            len([r for r in captor.records
                 if "Table version value is a float" in r.msg]) == 1)


class VheaDecompileOrFromXMLTest(unittest.TestCase):

    def setUp(self):
        vhea = newTable('vhea')
        self.font = TTFont(sfntVersion='OTTO')
        self.font['vhea'] = vhea

    def test_decompile_version_10(self):
        vhea = self.font['vhea']
        vhea.decompile(VHEA_DATA_VERSION_10, self.font)
        for key in vhea.__dict__:
            self.assertEqual(getattr(vhea, key), VHEA_VERSION_10_AS_DICT[key])

    def test_decompile_version_11(self):
        vhea = self.font['vhea']
        vhea.decompile(VHEA_DATA_VERSION_11, self.font)
        for key in vhea.__dict__:
            self.assertEqual(getattr(vhea, key), VHEA_VERSION_11_AS_DICT[key])

    def test_fromXML_version_10(self):
        vhea = self.font['vhea']
        for name, attrs, content in parseXML(VHEA_XML_VERSION_10):
            vhea.fromXML(name, attrs, content, self.font)
        for key in vhea.__dict__:
            self.assertEqual(getattr(vhea, key), VHEA_VERSION_10_AS_DICT[key])

    def test_fromXML_version_10_as_float(self):
        vhea = self.font['vhea']
        with CapturingLogHandler(log, "WARNING") as captor:
            for name, attrs, content in parseXML(VHEA_XML_VERSION_10_AS_FLOAT):
                vhea.fromXML(name, attrs, content, self.font)
        self.assertTrue(
            len([r for r in captor.records
                 if "Table version value is a float" in r.msg]) == 1)
        for key in vhea.__dict__:
            self.assertEqual(getattr(vhea, key), VHEA_VERSION_10_AS_DICT[key])

    def test_fromXML_version_11(self):
        vhea = self.font['vhea']
        for name, attrs, content in parseXML(VHEA_XML_VERSION_11):
            vhea.fromXML(name, attrs, content, self.font)
        for key in vhea.__dict__:
            self.assertEqual(getattr(vhea, key), VHEA_VERSION_11_AS_DICT[key])

    def test_fromXML_version_11_as_float(self):
        vhea = self.font['vhea']
        with CapturingLogHandler(log, "WARNING") as captor:
            for name, attrs, content in parseXML(VHEA_XML_VERSION_11_AS_FLOAT):
                vhea.fromXML(name, attrs, content, self.font)
        self.assertTrue(
            len([r for r in captor.records
                 if "Table version value is a float" in r.msg]) == 1)
        for key in vhea.__dict__:
            self.assertEqual(getattr(vhea, key), VHEA_VERSION_11_AS_DICT[key])


class VheaRecalcTest(unittest.TestCase):

    def test_recalc_TTF(self):
        font = TTFont()
        font.importXML(os.path.join(DATA_DIR, '_v_h_e_a_recalc_TTF.ttx'))
        vhea = font['vhea']
        vhea.recalc(font)
        self.assertEqual(vhea.advanceHeightMax, 900)
        self.assertEqual(vhea.minTopSideBearing, 200)
        self.assertEqual(vhea.minBottomSideBearing, 377)
        self.assertEqual(vhea.yMaxExtent, 312)

    def test_recalc_OTF(self):
        font = TTFont()
        font.importXML(os.path.join(DATA_DIR, '_v_h_e_a_recalc_OTF.ttx'))
        vhea = font['vhea']
        vhea.recalc(font)
        self.assertEqual(vhea.advanceHeightMax, 900)
        self.assertEqual(vhea.minTopSideBearing, 200)
        self.assertEqual(vhea.minBottomSideBearing, 377)
        self.assertEqual(vhea.yMaxExtent, 312)

    def test_recalc_empty(self):
        font = TTFont()
        font.importXML(os.path.join(DATA_DIR, '_v_h_e_a_recalc_empty.ttx'))
        vhea = font['vhea']
        vhea.recalc(font)
        self.assertEqual(vhea.advanceHeightMax, 900)
        self.assertEqual(vhea.minTopSideBearing, 0)
        self.assertEqual(vhea.minBottomSideBearing, 0)
        self.assertEqual(vhea.yMaxExtent, 0)


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