from fontTools.voltLib.error import VoltLibError
from typing import NamedTuple


class Pos(NamedTuple):
    adv: int
    dx: int
    dy: int
    adv_adjust_by: dict
    dx_adjust_by: dict
    dy_adjust_by: dict

    def __str__(self):
        res = ' POS'
        for attr in ('adv', 'dx', 'dy'):
            value = getattr(self, attr)
            if value is not None:
                res += f' {attr.upper()} {value}'
                adjust_by = getattr(self, f'{attr}_adjust_by', {})
                for size, adjustment in adjust_by.items():
                    res += f' ADJUST_BY {adjustment} AT {size}'
        res += ' END_POS'
        return res


class Element(object):
    def __init__(self, location=None):
        self.location = location

    def build(self, builder):
        pass

    def __str__(self):
        raise NotImplementedError


class Statement(Element):
    pass


class Expression(Element):
    pass


class VoltFile(Statement):
    def __init__(self):
        Statement.__init__(self, location=None)
        self.statements = []

    def build(self, builder):
        for s in self.statements:
            s.build(builder)

    def __str__(self):
        return '\n' + '\n'.join(str(s) for s in self.statements) + ' END\n'


class GlyphDefinition(Statement):
    def __init__(self, name, gid, gunicode, gtype, components, location=None):
        Statement.__init__(self, location)
        self.name = name
        self.id = gid
        self.unicode = gunicode
        self.type = gtype
        self.components = components

    def __str__(self):
        res = f'DEF_GLYPH "{self.name}" ID {self.id}'
        if self.unicode is not None:
            if len(self.unicode) > 1:
                unicodes = ','.join(f'U+{u:04X}' for u in self.unicode)
                res += f' UNICODEVALUES "{unicodes}"'
            else:
                res += f' UNICODE {self.unicode[0]}'
        if self.type is not None:
            res += f' TYPE {self.type}'
        if self.components is not None:
            res += f' COMPONENTS {self.components}'
        res += ' END_GLYPH'
        return res


class GroupDefinition(Statement):
    def __init__(self, name, enum, location=None):
        Statement.__init__(self, location)
        self.name = name
        self.enum = enum
        self.glyphs_ = None

    def glyphSet(self, groups=None):
        if groups is not None and self.name in groups:
            raise VoltLibError(
                'Group "%s" contains itself.' % (self.name),
                self.location)
        if self.glyphs_ is None:
            if groups is None:
                groups = set({self.name})
            else:
                groups.add(self.name)
            self.glyphs_ = self.enum.glyphSet(groups)
        return self.glyphs_

    def __str__(self):
        enum = self.enum and str(self.enum) or ''
        return f'DEF_GROUP "{self.name}"\n{enum}\nEND_GROUP'


class GlyphName(Expression):
    """A single glyph name, such as cedilla."""
    def __init__(self, glyph, location=None):
        Expression.__init__(self, location)
        self.glyph = glyph

    def glyphSet(self):
        return (self.glyph,)

    def __str__(self):
        return f' GLYPH "{self.glyph}"'


class Enum(Expression):
    """An enum"""
    def __init__(self, enum, location=None):
        Expression.__init__(self, location)
        self.enum = enum

    def __iter__(self):
        for e in self.glyphSet():
            yield e

    def glyphSet(self, groups=None):
        glyphs = []
        for element in self.enum:
            if isinstance(element, (GroupName, Enum)):
                glyphs.extend(element.glyphSet(groups))
            else:
                glyphs.extend(element.glyphSet())
        return tuple(glyphs)

    def __str__(self):
        enum = ''.join(str(e) for e in self.enum)
        return f' ENUM{enum} END_ENUM'


class GroupName(Expression):
    """A glyph group"""
    def __init__(self, group, parser, location=None):
        Expression.__init__(self, location)
        self.group = group
        self.parser_ = parser

    def glyphSet(self, groups=None):
        group = self.parser_.resolve_group(self.group)
        if group is not None:
            self.glyphs_ = group.glyphSet(groups)
            return self.glyphs_
        else:
            raise VoltLibError(
                'Group "%s" is used but undefined.' % (self.group),
                self.location)

    def __str__(self):
        return f' GROUP "{self.group}"'


class Range(Expression):
    """A glyph range"""
    def __init__(self, start, end, parser, location=None):
        Expression.__init__(self, location)
        self.start = start
        self.end = end
        self.parser = parser

    def glyphSet(self):
        return tuple(self.parser.glyph_range(self.start, self.end))

    def __str__(self):
        return f' RANGE "{self.start}" TO "{self.end}"'


class ScriptDefinition(Statement):
    def __init__(self, name, tag, langs, location=None):
        Statement.__init__(self, location)
        self.name = name
        self.tag = tag
        self.langs = langs

    def __str__(self):
        res = 'DEF_SCRIPT'
        if self.name is not None:
            res += f' NAME "{self.name}"'
        res += f' TAG "{self.tag}"\n\n'
        for lang in self.langs:
            res += f'{lang}'
        res += 'END_SCRIPT'
        return res


class LangSysDefinition(Statement):
    def __init__(self, name, tag, features, location=None):
        Statement.__init__(self, location)
        self.name = name
        self.tag = tag
        self.features = features

    def __str__(self):
        res = 'DEF_LANGSYS'
        if self.name is not None:
            res += f' NAME "{self.name}"'
        res += f' TAG "{self.tag}"\n\n'
        for feature in self.features:
            res += f'{feature}'
        res += 'END_LANGSYS\n'
        return res


class FeatureDefinition(Statement):
    def __init__(self, name, tag, lookups, location=None):
        Statement.__init__(self, location)
        self.name = name
        self.tag = tag
        self.lookups = lookups

    def __str__(self):
        res = f'DEF_FEATURE NAME "{self.name}" TAG "{self.tag}"\n'
        res += ' ' + ' '.join(f'LOOKUP "{l}"' for l in self.lookups) + '\n'
        res += 'END_FEATURE\n'
        return res


class LookupDefinition(Statement):
    def __init__(self, name, process_base, process_marks, mark_glyph_set,
                 direction, reversal, comments, context, sub, pos,
                 location=None):
        Statement.__init__(self, location)
        self.name = name
        self.process_base = process_base
        self.process_marks = process_marks
        self.mark_glyph_set = mark_glyph_set
        self.direction = direction
        self.reversal = reversal
        self.comments = comments
        self.context = context
        self.sub = sub
        self.pos = pos

    def __str__(self):
        res = f'DEF_LOOKUP "{self.name}"'
        res += f' {self.process_base and "PROCESS_BASE" or "SKIP_BASE"}'
        if self.process_marks:
            res += ' PROCESS_MARKS '
            if self.mark_glyph_set:
                res += f'MARK_GLYPH_SET "{self.mark_glyph_set}"'
            elif isinstance(self.process_marks, str):
                res += f'"{self.process_marks}"'
            else:
                res += 'ALL'
        else:
            res += ' SKIP_MARKS'
        if self.direction is not None:
            res += f' DIRECTION {self.direction}'
        if self.reversal:
            res += ' REVERSAL'
        if self.comments is not None:
            comments = self.comments.replace('\n', r'\n')
            res += f'\nCOMMENTS "{comments}"'
        if self.context:
            res += '\n' + '\n'.join(str(c) for c in self.context)
        else:
            res += '\nIN_CONTEXT\nEND_CONTEXT'
        if self.sub:
            res += f'\n{self.sub}'
        if self.pos:
            res += f'\n{self.pos}'
        return res


class SubstitutionDefinition(Statement):
    def __init__(self, mapping, location=None):
        Statement.__init__(self, location)
        self.mapping = mapping

    def __str__(self):
        res = 'AS_SUBSTITUTION\n'
        for src, dst in self.mapping.items():
            src = ''.join(str(s) for s in src)
            dst = ''.join(str(d) for d in dst)
            res += f'SUB{src}\nWITH{dst}\nEND_SUB\n'
        res += 'END_SUBSTITUTION'
        return res


class SubstitutionSingleDefinition(SubstitutionDefinition):
    pass


class SubstitutionMultipleDefinition(SubstitutionDefinition):
    pass


class SubstitutionLigatureDefinition(SubstitutionDefinition):
    pass


class SubstitutionReverseChainingSingleDefinition(SubstitutionDefinition):
    pass


class PositionAttachDefinition(Statement):
    def __init__(self, coverage, coverage_to, location=None):
        Statement.__init__(self, location)
        self.coverage = coverage
        self.coverage_to = coverage_to

    def __str__(self):
        coverage = ''.join(str(c) for c in self.coverage)
        res = f'AS_POSITION\nATTACH{coverage}\nTO'
        for coverage, anchor in self.coverage_to:
            coverage = ''.join(str(c) for c in coverage)
            res += f'{coverage} AT ANCHOR "{anchor}"'
        res += '\nEND_ATTACH\nEND_POSITION'
        return res


class PositionAttachCursiveDefinition(Statement):
    def __init__(self, coverages_exit, coverages_enter, location=None):
        Statement.__init__(self, location)
        self.coverages_exit = coverages_exit
        self.coverages_enter = coverages_enter

    def __str__(self):
        res = 'AS_POSITION\nATTACH_CURSIVE'
        for coverage in self.coverages_exit:
            coverage = ''.join(str(c) for c in coverage)
            res += f'\nEXIT {coverage}'
        for coverage in self.coverages_enter:
            coverage = ''.join(str(c) for c in coverage)
            res += f'\nENTER {coverage}'
        res += '\nEND_ATTACH\nEND_POSITION'
        return res


class PositionAdjustPairDefinition(Statement):
    def __init__(self, coverages_1, coverages_2, adjust_pair, location=None):
        Statement.__init__(self, location)
        self.coverages_1 = coverages_1
        self.coverages_2 = coverages_2
        self.adjust_pair = adjust_pair

    def __str__(self):
        res = 'AS_POSITION\nADJUST_PAIR\n'
        for coverage in self.coverages_1:
            coverage = ' '.join(str(c) for c in coverage)
            res += f' FIRST {coverage}'
        res += '\n'
        for coverage in self.coverages_2:
            coverage = ' '.join(str(c) for c in coverage)
            res += f' SECOND {coverage}'
        res += '\n'
        for (id_1, id_2), (pos_1, pos_2) in self.adjust_pair.items():
            res += f' {id_1} {id_2} BY{pos_1}{pos_2}\n'
        res += '\nEND_ADJUST\nEND_POSITION'
        return res


class PositionAdjustSingleDefinition(Statement):
    def __init__(self, adjust_single, location=None):
        Statement.__init__(self, location)
        self.adjust_single = adjust_single

    def __str__(self):
        res = 'AS_POSITION\nADJUST_SINGLE'
        for coverage, pos in self.adjust_single:
            coverage = ''.join(str(c) for c in coverage)
            res += f'{coverage} BY{pos}'
        res += '\nEND_ADJUST\nEND_POSITION'
        return res


class ContextDefinition(Statement):
    def __init__(self, ex_or_in, left=None, right=None, location=None):
        Statement.__init__(self, location)
        self.ex_or_in = ex_or_in
        self.left = left if left is not None else []
        self.right = right if right is not None else []

    def __str__(self):
        res = self.ex_or_in + '\n'
        for coverage in self.left:
            coverage = ''.join(str(c) for c in coverage)
            res += f' LEFT{coverage}\n'
        for coverage in self.right:
            coverage = ''.join(str(c) for c in coverage)
            res += f' RIGHT{coverage}\n'
        res += 'END_CONTEXT'
        return res


class AnchorDefinition(Statement):
    def __init__(self, name, gid, glyph_name, component, locked,
                 pos, location=None):
        Statement.__init__(self, location)
        self.name = name
        self.gid = gid
        self.glyph_name = glyph_name
        self.component = component
        self.locked = locked
        self.pos = pos

    def __str__(self):
        locked = self.locked and ' LOCKED' or ''
        return (f'DEF_ANCHOR "{self.name}"'
                f' ON {self.gid}'
                f' GLYPH {self.glyph_name}'
                f' COMPONENT {self.component}'
                f'{locked}'
                f' AT {self.pos} END_ANCHOR')


class SettingDefinition(Statement):
    def __init__(self, name, value, location=None):
        Statement.__init__(self, location)
        self.name = name
        self.value = value

    def __str__(self):
        if self.value is True:
            return f'{self.name}'
        if isinstance(self.value, (tuple, list)):
            value = " ".join(str(v) for v in self.value)
            return f'{self.name} {value}'
        return f'{self.name} {self.value}'