#!/usr/bin/env python
import logging
import os
import sys
import re
from argparse import ArgumentParser
from collections import OrderedDict

import fontTools.feaLib.ast as feaast
import glyphsLib
from fontTools.ttLib import TTFont
from glyphsLib.classes import GSAnchor, GSClass, GSFeature, GSFeaturePrefix, Point
from lxml import etree

import fontFeatures
from fontFeatures.feaLib.FontFeatures import add_language_system_statements
from fontFeatures.ttLib import unparse
from fontFeatures.ttLib.GDEFUnparser import GDEFUnparser

LOGLEVEL = os.environ.get("LOGLEVEL", "WARNING").upper()
logging.basicConfig(level=LOGLEVEL)

import warnings


def warning_on_one_line(message, category, filename, lineno, file=None, line=None):
    return "# [warning] %s\n" % (message)


warnings.formatwarning = warning_on_one_line

parser = ArgumentParser()
parser.add_argument("source", help="source file to process", metavar="SOURCE")
parser.add_argument("firstmaster", help="binary font file to process", metavar="TTF")
parser.add_argument("--no-kerning", help="Don't try to convert kerning", action="store_true")
parser.add_argument(
    "-o",
    "--output",
    dest="output",
    help="Output source file (defaults to overwriting original)",
)
parser.add_argument(
    "--config", default=None, help="config file to process", metavar="CONFIG"
)
parser.add_argument("othermasters", help="additional binary masters", metavar="TTF", nargs="*")

args = parser.parse_args()

config = {}
if args.config:
    import json

    with open(args.config) as f:
        config = json.load(f)

class Layout2Glyphs:
    def __init__(self, gsfont, ff, args, master=0):
        self.gsfont = gsfont
        self.ff = ff
        self.master = master
        self.args = args

    def process(self):
        self.process_gpos()

        self.fix_gdef_classes()
        self.add_named_classes()
        self.add_routines_to_feature_prefix()
        self.ensure_mark_mkmk()
        self.add_features_to_glyphs()
        self.add_language_systems()
        self.fix_duplicate_anchors()

    def process_gpos(self):
        for feature in ["mark", "mkmk", "abvm", "blwm", "dist"]:
            if feature in self.ff.features:
                self.add_anchors(feature)
        for feature in ["kern", "dist"]:
            if feature in ff.features and not args.no_kerning:
                self.add_kerning(feature)


    def add_anchor_to_glyph(self, glyphname, anchor_name, pos):
        anchor = GSAnchor(name=anchor_name, position=Point(*pos))
        glyph = self.gsfont.glyphs[glyphname]
        glyph.layers[self.master].anchors.append(anchor)
        return anchor

    def add_anchors(self, feature):
        mark = self.ff.features[feature]
        new_mark = []
        for rr in mark:
            routine = rr.routine
            delete_me = False
            if "MarkToLigature" in routine.name:
                self.add_mark_lig_anchors(routine.name, routine.comments[2:-1])
                delete_me = True
            else:
                delete_me = self.add_anchors_routine(routine)
            if not delete_me:
                new_mark.append(rr)
            else:
                del self.ff.routines[self.ff.routines.index(routine)]
        self.ff.features[feature] = new_mark

    def add_anchors_routine(self, routine):
        delete_me = False
        for rule in routine.rules:
            if isinstance(rule, fontFeatures.Attachment):
                delete_me = True
                if "Cursive" in routine.name:
                    anchor_name = "entry"
                else:
                    anchor_name = rule.base_name
                for base, pos in rule.bases.items():
                    self.add_anchor_to_glyph(base, anchor_name, pos)
                if "Cursive" in routine.name:
                    anchor_name = "exit"
                else:
                    anchor_name = "_"+rule.base_name
                for mark, pos in rule.marks.items():
                    self.add_anchor_to_glyph(mark, anchor_name, pos)
        return delete_me

    def add_kern(self, left, right, val):
        old_val = self.gsfont.kerningForPair(
            self.gsfont.masters[self.master].id,
            left,
            right,
        )
        if old_val == self.gsfont.EMPTY_KERNING_VALUE:
            old_val = 0
        else:
            print("Adding %i to existing kern %s/%s=%i" % (val, left, right, old_val))
        if not val:
            return
        self.gsfont.setKerningForPair(
            self.gsfont.masters[self.master].id,
            left,
            right,
            old_val + val
        )

    def add_kerning(self, feature):
        kern = self.ff.features[feature]
        new_kern = []
        for rr in kern:
            routine = rr.routine
            delete_me = False
            pairs = set()
            for rule in routine.rules:
                if isinstance(rule, fontFeatures.Positioning):
                    # Is it pair positioning
                    if len(rule.glyphs) != 2:
                        break
                    # Is it a simple kern?
                    if not (rule.valuerecords[0] and not rule.valuerecords[1]):
                        continue
                    if not rule.valuerecords[0].xAdvance:
                        continue
                    if rule.valuerecords[0].xPlacement or rule.valuerecords[0].yPlacement:
                        continue
                    for left in rule.glyphs[0]:
                        for right in rule.glyphs[1]:
                            if (left, right) in pairs:
                                continue
                            pairs.add((left,right))
                            self.add_kern(left, right, rule.valuerecords[0].xAdvance)
                            print(
                                "# Kerning %s %s = %i"
                                % (left, right, rule.valuerecords[0].xAdvance)
                            )
                    delete_me = True

            if not delete_me:
                new_kern.append(rr)
            elif routine in ff.routines:
                del ff.routines[ff.routines.index(routine)]
        ff.features[feature] = new_kern

    def add_mark_lig_anchors(self, name, xml):
        xml = "\n".join([re.sub(r"#\s+", "", c) for c in xml])
        tree = etree.fromstring(xml)
        marks = [x.get("value") for x in tree.xpath("//*/MarkCoverage/Glyph")]
        ligs = [x.get("value") for x in tree.xpath("//*/LigatureCoverage/Glyph")]
        array = tree.xpath("//*/LigatureArray")[0]
        for ligature, attach in zip(ligs, array.iter("LigatureAttach")):
            for ix, cr in enumerate(attach.iter("ComponentRecord")):
                for markclass, anchor in enumerate(cr.iter("LigatureAnchor")):
                    x = int(anchor.xpath(".//XCoordinate")[0].get("value"))
                    y = int(anchor.xpath(".//YCoordinate")[0].get("value"))
                    anchor_name = name+f"_class{markclass}_"+str(1 + ix)
                    self.add_anchor_to_glyph(ligature, anchor_name, (x,y))

        array = tree.xpath("//*/MarkArray")[0]
        for mark, attach in zip(marks, array.iter("MarkRecord")):
            markclass = int(attach.find("Class").get("value"))
            anchor_name = "_"+name+f"_class{markclass}"
            x = int(attach.xpath(".//XCoordinate")[0].get("value"))
            y = int(attach.xpath(".//YCoordinate")[0].get("value"))
            anchor = self.add_anchor_to_glyph(mark, anchor_name, (x,y))

    def fix_gdef_classes(self):
        for glyph, cat in self.ff.glyphclasses.items():
            if cat == "mark":
                self.gsfont.glyphs[glyph].category = "Mark"
                if self.gsfont.glyphs[glyph].layers[0].width == 0:
                    self.gsfont.glyphs[glyph].subCategory = "Nonspacing"
                else:
                    self.gsfont.glyphs[glyph].subCategory = "Spacing Combining"
            if cat == "ligature":
                self.gsfont.glyphs[glyph].category = "Letter"
                self.gsfont.glyphs[glyph].subCategory = "Ligature"

    def add_named_classes(self):
        ff.asFea()
        for cls, members in self.ff.namedClasses.items():
            self.gsfont.classes.append(GSClass(name=cls, code=" ".join(members)))

    def add_feature_prefix(self, routine):
        self.gsfont.featurePrefixes.append(
            GSFeaturePrefix(name=routine.name, code=routine.asFea())
        )

    def add_routines_to_feature_prefix(self):
        # Lookups go into prefix, in order of dependency
        queue = list(self.ff.routines)
        seen = {}
        while queue:
            for dep in queue[0].dependencies:
                if dep not in seen:
                    queue.insert(0, dep)
            routine = queue.pop(0)
            if routine not in seen:
                self.add_feature_prefix(routine)
            seen[routine] = True

    def ensure_mark_mkmk(self):
        # Work around https://github.com/googlefonts/ufo2ft/issues/506
        if "mark" not in self.ff.features and "mkmk" in self.ff.features:
            newfeatures = OrderedDict()
            for k, v in self.ff.features.items():
                if k == "mkmk":
                    newfeatures["mark"] = []
                newfeatures[k] = v
            self.ff.features = newfeatures

    def add_features_to_glyphs(self):
        for featuretag, routines in self.ff.features.items():
            code = "\n".join([
                f"# {routine.languages}\n"+
                routine.asFea() for routine in routines
            ])
            if featuretag in ["mark", "mkmk", "dist", "kern", "abvm", "blwm"]:
                code = "# Automatic Code Start\n" + code
            self.gsfont.features.append(GSFeature(name=featuretag, code=code))

    def add_language_systems(self):
        code = ""
        for script, langs in self.ff.scripts_and_languages.items():
            for lang in langs:
                code += f"languagesystem {script} {lang};\n"
        self.gsfont.featurePrefixes.append(GSFeaturePrefix(name="Languagesystems", code=code))

    def fix_duplicate_anchors(self):
        #  Get names of all anchors
        glyphs_with_anchor = {}
        for g in self.gsfont.glyphs:
            for l in g.layers:
                for a in l.anchors:
                    glyphs_with_anchor.setdefault(a.name, set()).add(g.name)

        our_anchors = [a for a in glyphs_with_anchor.keys() if "Anchor" in a]
        their_anchors = [a for a in glyphs_with_anchor.keys() if "Anchor" not in a]
        drop_anchors = set()
        if their_anchors:
            for theirs in their_anchors:
                for ours in our_anchors:
                    if glyphs_with_anchor[theirs] != glyphs_with_anchor[ours]:
                        continue
                    same = True
                    for g in glyphs_with_anchor[theirs]:
                        for l in self.gsfont.glyphs[g].layers:
                            if not l.anchors[theirs]:
                                print("Bad anchor %s in %s" % (theirs, l))
                                same = False
                            elif not l.anchors[ours]:
                                print("Bad anchor %s in %s" % (ours, l))
                                same = False
                            elif l.anchors[theirs].position != l.anchors[ours].position:
                                same = False
                    if not same:
                        continue
                    print("Our anchor '%s' was duplicate of original source '%s'" % (ours, theirs))
                    drop_anchors.add(ours)
                    break

        for to_drop in drop_anchors:
            for glyph in glyphs_with_anchor[to_drop]:
                for l in self.gsfont.glyphs[glyph].layers:
                    del l.anchors[to_drop]

gsfont = glyphsLib.load(open(args.source))

font = TTFont(args.firstmaster)

ff = unparse(font, do_gdef=True, doLookups=True, config=config)

Layout2Glyphs(gsfont, ff, args).process()

for ix, master in enumerate(args.othermasters):
    print("%s -> %i" % (master, ix+1))
    font = TTFont(master)
    ff = unparse(font, do_gdef=True, doLookups=True, config=config)
    Layout2Glyphs(gsfont, ff, args, master=ix+1).process_gpos()

if not args.output:
    args.output = args.source
gsfont.save(args.output)
print(f"Saved {args.output}")
