from fontTools.misc import sstruct
from fontTools.misc.fixedTools import floatToFixedToStr
from fontTools.misc.textTools import safeEval

# from itertools import *
from functools import partial
from . import DefaultTable
from . import grUtils
import struct


Glat_format_0 = """
    >        # big endian
    version: 16.16F
"""

Glat_format_3 = """
    >
    version: 16.16F
    compression:L    # compression scheme or reserved 
"""

Glat_format_1_entry = """
    >
    attNum:     B    # Attribute number of first attribute
    num:        B    # Number of attributes in this run
"""
Glat_format_23_entry = """
    >
    attNum:     H    # Attribute number of first attribute
    num:        H    # Number of attributes in this run
"""

Glat_format_3_octabox_metrics = """
    >
    subboxBitmap:   H    # Which subboxes exist on 4x4 grid
    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
"""

Glat_format_3_subbox_entry = """
    >
    left:           B    # xi
    right:          B    # xa
    bottom:         B    # yi
    top:            B    # ya
    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
"""


class _Object:
    pass


class _Dict(dict):
    pass


class table_G__l_a_t(DefaultTable.DefaultTable):
    """
    Support Graphite Glat tables
    """

    def __init__(self, tag=None):
        DefaultTable.DefaultTable.__init__(self, tag)
        self.scheme = 0

    def decompile(self, data, ttFont):
        sstruct.unpack2(Glat_format_0, data, self)
        self.version = float(floatToFixedToStr(self.version, precisionBits=16))
        if self.version <= 1.9:
            decoder = partial(self.decompileAttributes12, fmt=Glat_format_1_entry)
        elif self.version <= 2.9:
            decoder = partial(self.decompileAttributes12, fmt=Glat_format_23_entry)
        elif self.version >= 3.0:
            (data, self.scheme) = grUtils.decompress(data)
            sstruct.unpack2(Glat_format_3, data, self)
            self.hasOctaboxes = (self.compression & 1) == 1
            decoder = self.decompileAttributes3

        gloc = ttFont["Gloc"]
        self.attributes = {}
        count = 0
        for s, e in zip(gloc, gloc[1:]):
            self.attributes[ttFont.getGlyphName(count)] = decoder(data[s:e])
            count += 1

    def decompileAttributes12(self, data, fmt):
        attributes = _Dict()
        while len(data) > 3:
            e, data = sstruct.unpack2(fmt, data, _Object())
            keys = range(e.attNum, e.attNum + e.num)
            if len(data) >= 2 * e.num:
                vals = struct.unpack_from((">%dh" % e.num), data)
                attributes.update(zip(keys, vals))
                data = data[2 * e.num :]
        return attributes

    def decompileAttributes3(self, data):
        if self.hasOctaboxes:
            o, data = sstruct.unpack2(Glat_format_3_octabox_metrics, data, _Object())
            numsub = bin(o.subboxBitmap).count("1")
            o.subboxes = []
            for b in range(numsub):
                if len(data) >= 8:
                    subbox, data = sstruct.unpack2(
                        Glat_format_3_subbox_entry, data, _Object()
                    )
                    o.subboxes.append(subbox)
        attrs = self.decompileAttributes12(data, Glat_format_23_entry)
        if self.hasOctaboxes:
            attrs.octabox = o
        return attrs

    def compile(self, ttFont):
        data = sstruct.pack(Glat_format_0, self)
        if self.version <= 1.9:
            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
        elif self.version <= 2.9:
            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
        elif self.version >= 3.0:
            self.compression = (self.scheme << 27) + (1 if self.hasOctaboxes else 0)
            data = sstruct.pack(Glat_format_3, self)
            encoder = self.compileAttributes3

        glocs = []
        for n in range(len(self.attributes)):
            glocs.append(len(data))
            data += encoder(self.attributes[ttFont.getGlyphName(n)])
        glocs.append(len(data))
        ttFont["Gloc"].set(glocs)

        if self.version >= 3.0:
            data = grUtils.compress(self.scheme, data)
        return data

    def compileAttributes12(self, attrs, fmt):
        data = b""
        for e in grUtils.entries(attrs):
            data += sstruct.pack(fmt, {"attNum": e[0], "num": e[1]}) + struct.pack(
                (">%dh" % len(e[2])), *e[2]
            )
        return data

    def compileAttributes3(self, attrs):
        if self.hasOctaboxes:
            o = attrs.octabox
            data = sstruct.pack(Glat_format_3_octabox_metrics, o)
            numsub = bin(o.subboxBitmap).count("1")
            for b in range(numsub):
                data += sstruct.pack(Glat_format_3_subbox_entry, o.subboxes[b])
        else:
            data = ""
        return data + self.compileAttributes12(attrs, Glat_format_23_entry)

    def toXML(self, writer, ttFont):
        writer.simpletag("version", version=self.version, compressionScheme=self.scheme)
        writer.newline()
        for n, a in sorted(
            self.attributes.items(), key=lambda x: ttFont.getGlyphID(x[0])
        ):
            writer.begintag("glyph", name=n)
            writer.newline()
            if hasattr(a, "octabox"):
                o = a.octabox
                formatstring, names, fixes = sstruct.getformat(
                    Glat_format_3_octabox_metrics
                )
                vals = {}
                for k in names:
                    if k == "subboxBitmap":
                        continue
                    vals[k] = "{:.3f}%".format(getattr(o, k) * 100.0 / 255)
                vals["bitmap"] = "{:0X}".format(o.subboxBitmap)
                writer.begintag("octaboxes", **vals)
                writer.newline()
                formatstring, names, fixes = sstruct.getformat(
                    Glat_format_3_subbox_entry
                )
                for s in o.subboxes:
                    vals = {}
                    for k in names:
                        vals[k] = "{:.3f}%".format(getattr(s, k) * 100.0 / 255)
                    writer.simpletag("octabox", **vals)
                    writer.newline()
                writer.endtag("octaboxes")
                writer.newline()
            for k, v in sorted(a.items()):
                writer.simpletag("attribute", index=k, value=v)
                writer.newline()
            writer.endtag("glyph")
            writer.newline()

    def fromXML(self, name, attrs, content, ttFont):
        if name == "version":
            self.version = float(safeEval(attrs["version"]))
            self.scheme = int(safeEval(attrs["compressionScheme"]))
        if name != "glyph":
            return
        if not hasattr(self, "attributes"):
            self.attributes = {}
        gname = attrs["name"]
        attributes = _Dict()
        for element in content:
            if not isinstance(element, tuple):
                continue
            tag, attrs, subcontent = element
            if tag == "attribute":
                k = int(safeEval(attrs["index"]))
                v = int(safeEval(attrs["value"]))
                attributes[k] = v
            elif tag == "octaboxes":
                self.hasOctaboxes = True
                o = _Object()
                o.subboxBitmap = int(attrs["bitmap"], 16)
                o.subboxes = []
                del attrs["bitmap"]
                for k, v in attrs.items():
                    setattr(o, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
                for element in subcontent:
                    if not isinstance(element, tuple):
                        continue
                    (tag, attrs, subcontent) = element
                    so = _Object()
                    for k, v in attrs.items():
                        setattr(so, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
                    o.subboxes.append(so)
                attributes.octabox = o
        self.attributes[gname] = attributes
