from fontTools.ttLib import newTable
from fontTools.ttLib.tables._k_e_r_n import KernTable_format_0, KernTable_format_unkown
from fontTools.misc.textTools import deHexStr
from fontTools.misc.testTools import FakeFont, getXML, parseXML
import itertools
import pytest


KERN_VER_0_FMT_0_DATA = deHexStr(
    "0000 "  #  0: version=0
    "0001 "  #  2: nTables=1
    "0000 "  #  4: version=0 (bogus field, unused)
    "0020 "  #  6: length=32
    "00 "  #  8: format=0
    "01 "  #  9: coverage=1
    "0003 "  # 10: nPairs=3
    "000C "  # 12: searchRange=12
    "0001 "  # 14: entrySelector=1
    "0006 "  # 16: rangeShift=6
    "0004 000C FFD8 "  # 18: l=4, r=12, v=-40
    "0004 001C 0028 "  # 24: l=4, r=28, v=40
    "0005 0028 FFCE "  # 30: l=5, r=40, v=-50
)
assert len(KERN_VER_0_FMT_0_DATA) == 36

KERN_VER_0_FMT_0_XML = [
    '<version value="0"/>',
    '<kernsubtable coverage="1" format="0">',
    '  <pair l="E" r="M" v="-40"/>',
    '  <pair l="E" r="c" v="40"/>',
    '  <pair l="F" r="o" v="-50"/>',
    "</kernsubtable>",
]

KERN_VER_1_FMT_0_DATA = deHexStr(
    "0001 0000 "  #  0: version=1
    "0000 0001 "  #  4: nTables=1
    "0000 0022 "  #  8: length=34
    "00 "  # 12: coverage=0
    "00 "  # 13: format=0
    "0000 "  # 14: tupleIndex=0
    "0003 "  # 16: nPairs=3
    "000C "  # 18: searchRange=12
    "0001 "  # 20: entrySelector=1
    "0006 "  # 22: rangeShift=6
    "0004 000C FFD8 "  # 24: l=4, r=12, v=-40
    "0004 001C 0028 "  # 30: l=4, r=28, v=40
    "0005 0028 FFCE "  # 36: l=5, r=40, v=-50
)
assert len(KERN_VER_1_FMT_0_DATA) == 42

KERN_VER_1_FMT_0_XML = [
    '<version value="1.0"/>',
    '<kernsubtable coverage="0" format="0" tupleIndex="0">',
    '  <pair l="E" r="M" v="-40"/>',
    '  <pair l="E" r="c" v="40"/>',
    '  <pair l="F" r="o" v="-50"/>',
    "</kernsubtable>",
]

KERN_VER_0_FMT_UNKNOWN_DATA = deHexStr(
    "0000 "  #  0: version=0
    "0002 "  #  2: nTables=2
    "0000 "  #  4: version=0
    "000A "  #  6: length=10
    "04 "  #  8: format=4  (format 4 doesn't exist)
    "01 "  #  9: coverage=1
    "1234 5678 "  # 10: garbage...
    "0000 "  # 14: version=0
    "000A "  # 16: length=10
    "05 "  # 18: format=5  (format 5 doesn't exist)
    "01 "  # 19: coverage=1
    "9ABC DEF0 "  # 20: garbage...
)
assert len(KERN_VER_0_FMT_UNKNOWN_DATA) == 24

KERN_VER_0_FMT_UNKNOWN_XML = [
    '<version value="0"/>',
    '<kernsubtable format="4">',
    "  <!-- unknown 'kern' subtable format -->",
    "  0000000A 04011234",
    "  5678             ",
    "</kernsubtable>",
    '<kernsubtable format="5">',
    "<!-- unknown 'kern' subtable format -->",
    "  0000000A 05019ABC",
    "  DEF0             ",
    "</kernsubtable>",
]

KERN_VER_1_FMT_UNKNOWN_DATA = deHexStr(
    "0001 0000 "  #  0: version=1
    "0000 0002 "  #  4: nTables=2
    "0000 000C "  #  8: length=12
    "00 "  # 12: coverage=0
    "04 "  # 13: format=4  (format 4 doesn't exist)
    "0000 "  # 14: tupleIndex=0
    "1234 5678"  # 16: garbage...
    "0000 000C "  # 20: length=12
    "00 "  # 24: coverage=0
    "05 "  # 25: format=5  (format 5 doesn't exist)
    "0000 "  # 26: tupleIndex=0
    "9ABC DEF0 "  # 28: garbage...
)
assert len(KERN_VER_1_FMT_UNKNOWN_DATA) == 32

KERN_VER_1_FMT_UNKNOWN_XML = [
    '<version value="1"/>',
    '<kernsubtable format="4">',
    "  <!-- unknown 'kern' subtable format -->",
    "  0000000C 00040000",
    "  12345678         ",
    "</kernsubtable>",
    '<kernsubtable format="5">',
    "  <!-- unknown 'kern' subtable format -->",
    "  0000000C 00050000",
    "  9ABCDEF0         ",
    "</kernsubtable>",
]

KERN_VER_0_FMT_0_OVERFLOWING_DATA = deHexStr(
    "0000 "  #  0: version=0
    "0001 "  #  2: nTables=1
    "0000 "  #  4: version=0 (bogus field, unused)
    "0274 "  #  6: length=628 (bogus value for 66164 % 0x10000)
    "00 "  #  8: format=0
    "01 "  #  9: coverage=1
    "2B11 "  # 10: nPairs=11025
    "C000 "  # 12: searchRange=49152
    "000D "  # 14: entrySelector=13
    "4266 "  # 16: rangeShift=16998
) + deHexStr(
    " ".join(
        "%04X %04X %04X" % (a, b, 0)
        for (a, b) in itertools.product(range(105), repeat=2)
    )
)


@pytest.fixture
def font():
    return FakeFont(list("ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"))


@pytest.fixture
def overflowing_font():
    return FakeFont(["glyph%i" % i for i in range(105)])


class KernTableTest(object):
    @pytest.mark.parametrize(
        "data, version",
        [
            (KERN_VER_0_FMT_0_DATA, 0),
            (KERN_VER_1_FMT_0_DATA, 1.0),
        ],
        ids=["version_0", "version_1"],
    )
    def test_decompile_single_format_0(self, data, font, version):
        kern = newTable("kern")
        kern.decompile(data, font)

        assert kern.version == version
        assert len(kern.kernTables) == 1

        st = kern.kernTables[0]
        assert st.apple is (version == 1.0)
        assert st.format == 0
        # horizontal kerning in OT kern is coverage 0x01, while in
        # AAT kern it's the default (0)
        assert st.coverage == (0 if st.apple else 1)
        assert st.tupleIndex == (0 if st.apple else None)
        assert len(st.kernTable) == 3
        assert st.kernTable == {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}

    @pytest.mark.parametrize(
        "version, expected",
        [
            (0, KERN_VER_0_FMT_0_DATA),
            (1.0, KERN_VER_1_FMT_0_DATA),
        ],
        ids=["version_0", "version_1"],
    )
    def test_compile_single_format_0(self, font, version, expected):
        kern = newTable("kern")
        kern.version = version
        apple = version == 1.0
        st = KernTable_format_0(apple)
        kern.kernTables = [st]
        st.coverage = 0 if apple else 1
        st.tupleIndex = 0 if apple else None
        st.kernTable = {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}
        data = kern.compile(font)
        assert data == expected

    @pytest.mark.parametrize(
        "xml, version",
        [
            (KERN_VER_0_FMT_0_XML, 0),
            (KERN_VER_1_FMT_0_XML, 1.0),
        ],
        ids=["version_0", "version_1"],
    )
    def test_fromXML_single_format_0(self, xml, font, version):
        kern = newTable("kern")
        for name, attrs, content in parseXML(xml):
            kern.fromXML(name, attrs, content, ttFont=font)

        assert kern.version == version
        assert len(kern.kernTables) == 1

        st = kern.kernTables[0]
        assert st.apple is (version == 1.0)
        assert st.format == 0
        assert st.coverage == (0 if st.apple else 1)
        assert st.tupleIndex == (0 if st.apple else None)
        assert len(st.kernTable) == 3
        assert st.kernTable == {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}

    @pytest.mark.parametrize(
        "version, expected",
        [
            (0, KERN_VER_0_FMT_0_XML),
            (1.0, KERN_VER_1_FMT_0_XML),
        ],
        ids=["version_0", "version_1"],
    )
    def test_toXML_single_format_0(self, font, version, expected):
        kern = newTable("kern")
        kern.version = version
        apple = version == 1.0
        st = KernTable_format_0(apple)
        kern.kernTables = [st]
        st.coverage = 0 if apple else 1
        st.tupleIndex = 0 if apple else None
        st.kernTable = {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}
        xml = getXML(kern.toXML, font)
        assert xml == expected

    @pytest.mark.parametrize(
        "data, version, header_length, st_length",
        [
            (KERN_VER_0_FMT_UNKNOWN_DATA, 0, 4, 10),
            (KERN_VER_1_FMT_UNKNOWN_DATA, 1.0, 8, 12),
        ],
        ids=["version_0", "version_1"],
    )
    def test_decompile_format_unknown(
        self, data, font, version, header_length, st_length
    ):
        kern = newTable("kern")
        kern.decompile(data, font)

        assert kern.version == version
        assert len(kern.kernTables) == 2

        st_data = data[header_length:]
        st0 = kern.kernTables[0]
        assert st0.format == 4
        assert st0.data == st_data[:st_length]
        st_data = st_data[st_length:]

        st1 = kern.kernTables[1]
        assert st1.format == 5
        assert st1.data == st_data[:st_length]

    @pytest.mark.parametrize(
        "version, st_length, expected",
        [
            (0, 10, KERN_VER_0_FMT_UNKNOWN_DATA),
            (1.0, 12, KERN_VER_1_FMT_UNKNOWN_DATA),
        ],
        ids=["version_0", "version_1"],
    )
    def test_compile_format_unknown(self, version, st_length, expected):
        kern = newTable("kern")
        kern.version = version
        kern.kernTables = []

        for unknown_fmt, kern_data in zip((4, 5), ("1234 5678", "9ABC DEF0")):
            if version > 0:
                coverage = 0
                header_fmt = deHexStr(
                    "%08X %02X %02X %04X" % (st_length, coverage, unknown_fmt, 0)
                )
            else:
                coverage = 1
                header_fmt = deHexStr(
                    "%04X %04X %02X %02X" % (0, st_length, unknown_fmt, coverage)
                )
            st = KernTable_format_unkown(unknown_fmt)
            st.data = header_fmt + deHexStr(kern_data)
            kern.kernTables.append(st)

        data = kern.compile(font)
        assert data == expected

    @pytest.mark.parametrize(
        "xml, version, st_length",
        [
            (KERN_VER_0_FMT_UNKNOWN_XML, 0, 10),
            (KERN_VER_1_FMT_UNKNOWN_XML, 1.0, 12),
        ],
        ids=["version_0", "version_1"],
    )
    def test_fromXML_format_unknown(self, xml, font, version, st_length):
        kern = newTable("kern")
        for name, attrs, content in parseXML(xml):
            kern.fromXML(name, attrs, content, ttFont=font)

        assert kern.version == version
        assert len(kern.kernTables) == 2

        st0 = kern.kernTables[0]
        assert st0.format == 4
        assert len(st0.data) == st_length

        st1 = kern.kernTables[1]
        assert st1.format == 5
        assert len(st1.data) == st_length

    @pytest.mark.parametrize("version", [0, 1.0], ids=["version_0", "version_1"])
    def test_toXML_format_unknown(self, font, version):
        kern = newTable("kern")
        kern.version = version
        st = KernTable_format_unkown(4)
        st.data = b"ABCD"
        kern.kernTables = [st]

        xml = getXML(kern.toXML, font)

        assert xml == [
            '<version value="%s"/>' % version,
            '<kernsubtable format="4">',
            "  <!-- unknown 'kern' subtable format -->",
            "  41424344   ",
            "</kernsubtable>",
        ]

    def test_getkern(self):
        table = newTable("kern")
        table.version = 0
        table.kernTables = []

        assert table.getkern(0) is None

        st0 = KernTable_format_0()
        table.kernTables.append(st0)

        assert table.getkern(0) is st0
        assert table.getkern(4) is None

        st1 = KernTable_format_unkown(4)
        table.kernTables.append(st1)


class KernTable_format_0_Test(object):
    def test_decompileBadGlyphId(self, font):
        subtable = KernTable_format_0()
        subtable.decompile(
            b"\x00"
            + b"\x00"
            + b"\x00"
            + b"\x1a"
            + b"\x00"
            + b"\x00"
            + b"\x00"
            + b"\x02"
            + b"\x00" * 6
            + b"\x00"
            + b"\x01"
            + b"\x00"
            + b"\x03"
            + b"\x00"
            + b"\x01"
            + b"\x00"
            + b"\x01"
            + b"\xFF"
            + b"\xFF"
            + b"\x00"
            + b"\x02",
            font,
        )
        assert subtable[("B", "D")] == 1
        assert subtable[("B", "glyph65535")] == 2

    def test_compileOverflowingSubtable(self, overflowing_font):
        font = overflowing_font
        kern = newTable("kern")
        kern.version = 0
        st = KernTable_format_0(0)
        kern.kernTables = [st]
        st.coverage = 1
        st.tupleIndex = None
        st.kernTable = {
            (a, b): 0 for (a, b) in itertools.product(font.getGlyphOrder(), repeat=2)
        }
        assert len(st.kernTable) == 11025
        data = kern.compile(font)
        assert data == KERN_VER_0_FMT_0_OVERFLOWING_DATA

    def test_decompileOverflowingSubtable(self, overflowing_font):
        font = overflowing_font
        data = KERN_VER_0_FMT_0_OVERFLOWING_DATA
        kern = newTable("kern")
        kern.decompile(data, font)

        st = kern.kernTables[0]
        assert st.kernTable == {
            (a, b): 0 for (a, b) in itertools.product(font.getGlyphOrder(), repeat=2)
        }


if __name__ == "__main__":
    import sys

    sys.exit(pytest.main(sys.argv))
