import color, method, mode
from lex import Grammar, Rule, PatternRule, RegionRule

class PatternGroupRule(PatternRule):
    def __init__(self, name, *args):
        assert args and len(args) % 2 == 0
        i = 0
        pairs = []
        while i < len(args):
            tokname, pattern = args[i], args[i+1]
            pairs.append((tokname, re.compile(pattern, self.reflags)))
            i += 2
        Rule.__init__(self, name)
        self.pairs = tuple(pairs)
    def match(self, lexer, parent):
        (x, y) = (lexer.x, lexer.y)
        matches = []
        for (tokname, tokre) in self.pairs:
            if y >= len(lexer.lines):
                return []
            line = self.get_line(lexer, y)
            m    = tokre.match(line, x)
            if m:
                x += len(m.group(0))
                if x >= len(line):
                    x = 0
                    y += 1
                matches.append((tokname, m))
            else:
                return []
        assert len(matches) == len(self.pairs)
        return matches
    def lex(self, lexer, parent, matches):
        if matches:
            for (tokname, m) in matches:
                yield self.make_token(lexer, m.group(0), tokname, parent, m.groupdict())
        raise StopIteration

class StringGrammar1(Grammar):
    rules = [
        PatternRule(r'data', r'[^"&]+'),
        PatternRule(r'escaped', r'&[a-z]+;'),
    ]
class StringGrammar2(Grammar):
    rules = [
        PatternRule(r'data', r"[^'&]+"),
        PatternRule(r'escaped', r'&[a-z]+;'),
    ]

class CDataGrammar(Grammar):
    rules = [PatternRule(r'data', r'(?:[^\]]|\](?!\])|\]\](?!>))+')]
class CommentGrammar(Grammar):
    rules = [PatternRule(r'data', r'(?:[^-]|-(?!-)|--(?!>))+')]
class MetadataGrammar(Grammar):
    rules = [PatternRule(r'data', r'(?:[^?]|\?(?!>))+')]

class TagGrammar(Grammar):
    rules = [
        PatternRule(r'attrname', r'[a-zA-Z_][a-zA-Z0-9_]+(?==)'),
        PatternRule(r'namespace', r'[a-zA-Z_]+(?=:)'),
        PatternRule(r'name', r'[a-zA-Z_][a-zA-Z0-9_]*'),
        PatternRule(r'delimiter', r'[/=]'),
        RegionRule(r'string', r'"', StringGrammar1, r'"'),
        RegionRule(r'string', r"'", StringGrammar2, r"'"),
        PatternRule(r'spaces', r' +'),
        PatternRule(r'eol', r'\n'),
    ]

class XMLGrammar(Grammar):
    rules = [
        # TODO: how does cdata work again?
        PatternRule(r'data', r'[^<& \n]+'),
        PatternRule(r'spaces', r' +'),
        RegionRule(r'comment', r'<!--', CommentGrammar, r'-->'),
        RegionRule(r'xml_cdata', r'<!\[CDATA\[', CDataGrammar, r'\]\]>'),
        RegionRule(r'xml_tag', r'<(?![?!])', TagGrammar, r'/?>'),
        PatternRule(r'xml_entity', r'&[a-z]+;'),
        PatternRule(r'eol', r'\n'),
        RegionRule(r'xml_metadata', r'<\?', MetadataGrammar, r'\?>'),
    ]

class XmlValidate(method.shell.Exec):
    '''Valid the buffer's contents as valid XML.'''
    show_success = True
    args         = []
    def _execute(self, w, **vargs):
        self._doit(w, w.buffer.path, 'xmlwf %(path)r', cmdname='xml-validate')

class XmlCreateTag(method.Method):
    '''Create an opening and closing tag'''
    args = [method.Argument('tagname', prompt="Tag Name: ", help="Create an open/close tag pair")]
    def _execute(self, w, **vargs):
        t = vargs['tagname']
        w.insert_string_at_cursor("<%s>" % t)
        p = w.logical_cursor()
        w.insert_string_at_cursor("</%s>" % t)
        w.goto(p)

class XmlCreateComment(method.Method):
    '''Create an opening and closing tag'''
    def _execute(self, w, **vargs):
        w.insert_string_at_cursor("<!-- ")
        p = w.logical_cursor()
        w.insert_string_at_cursor(" -->")
        w.goto(p)

class XmlCreateCdata(method.Method):
    '''Create an opening and closing tag'''
    def _execute(self, w, **vargs):
        w.insert_string_at_cursor("<![CDATA[")
        p = w.logical_cursor()
        w.insert_string_at_cursor("]]>")
        w.goto(p)

class XML(mode.Fundamental):
    modename   = 'XML'
    extensions = ['.xml', '.xml.in', '.xsl', '.xsd']
    grammar    = XMLGrammar
    colors     = {
        'xml_metadata.start':   ('magenta', 'default', 'bold'),
        'xml_metadata.data':    ('magenta', 'default', 'bold'),
        'xml_metadata.end':     ('magenta', 'default', 'bold'),
        'xml_tag.start':        ('default', 'default', 'bold'),
        'xml_tag.namespace':    ('magenta', 'default', 'bold'),
        'xml_tag.name':         ('blue', 'default', 'bold'),
        'xml_tag.attrname':     ('cyan', 'default', 'bold'),
        'xml_tag.string.start': ('green', 'default', 'bold'),
        'xml_tag.string.null':  ('green', 'default', 'bold'),
        'xml_tag.string.end':   ('green', 'default', 'bold'),
        'xml_tag.end':          ('default', 'default', 'bold'),
        'xml_entity':           ('magenta', 'default', 'bold'),
        'xml_cdata.start':      ('magenta', 'default', 'bold'),
        'xml_cdata.data':       ('green', 'default', 'bold'),
        'xml_cdata.end':        ('magenta', 'default', 'bold'),
    }
    actions = [XmlValidate, XmlCreateTag, XmlCreateComment, XmlCreateCdata]
    _bindings = {
        'xml-create-tag': ('M-t',),
    }
install = XML.install