#!/usr/bin/env python3

import functools

import importlib

import json

import os

import re

import sys

import types

import html

import pystache

from pygments import lexer as pygments_lexer

from pygments.token import _TokenType

TEMPLATE = r'''

<lexer>

  <config>

    <name>{{name}}</name>

    {{#aliases}}

    <alias>{{alias}}</alias>

    {{/aliases}}

    {{#filenames}}

    <filename>{{filename}}</filename>

    {{/filenames}}

    {{#mimetypes}}

    <mime_type>{{mimetype}}</mime_type>

    {{/mimetypes}}

    {{#re_ignorecase}}

    <case_insensitive>true</case_insensitive>

    {{/re_ignorecase}}

    {{#re_dotall}}

    <dot_all>true</dot_all>

    {{/re_dotall}}

    {{#re_not_multiline}}

    <not_multiline>true</not_multiline>

    {{/re_not_multiline}}

  </config>

  <rules>

    {{#tokens}}

    <state name="{{state}}">

      {{#rules}}

      {{{.}}}

      {{/rules}}

    </state>

    {{/tokens}}

  </rules>

</lexer>

'''

def xml_regex(s):

    return xml_string(s)

def xml_string(s):

    s = html.escape(s)

    return '"' + s + '"'

def to_camel_case(snake_str):

    components = snake_str.split('_')

    return ''.join(x.title() for x in components)

def warning(message):

    print('warning: ' + message, file=sys.stderr)

def resolve_emitter(emitter):

    if isinstance(emitter, types.FunctionType):

        if repr(emitter).startswith('<function bygroups.'):

            args = emitter.__closure__[0].cell_contents

            emitter = '<bygroups>%s</bygroups>' % ''.join(resolve_emitter(e) for e in args)

        elif repr(emitter).startswith('<function using.'):

            args = emitter.__closure__[0].cell_contents

            if isinstance(args, dict):

                state = 'root'

                if 'stack' in args:

                    state = args['stack'][1]

                    args.pop('stack')

                assert args == {}, args

                emitter = '<usingself state="%s"/>' % state

            elif issubclass(args, pygments_lexer.Lexer):

                name = args.__name__

                if name.endswith('Lexer'):

                    name = name[:-5]

                emitter = '<using lexer="%s"/>' % state

            else:

                raise ValueError('only support "using" with lexer classes, not %r' % args)

        else:

            warning('unsupported emitter function %r' % emitter)

            emitter = '?? %r ??' % emitter

    elif isinstance(emitter, _TokenType):

        emitter = '<token type="%s"/>' % str(emitter).replace('.', '')[5:]

    elif emitter is None:

        return 'None'

    else:

        raise ValueError('unsupported emitter type %r' % emitter)

    assert isinstance(emitter, str)

    return emitter

def process_state_action(action):

    if isinstance(action, tuple):

        return functools.reduce(lambda a, b: a + b, (process_state_action(a) for a in action))

    if action.startswith('#'):

        action = action[1:]

        if action== 'pop':

            action = '<pop depth="1"/>'

        elif action.startswith('pop:'):

            action = '<pop depth="%s"/>' % action[4:]

        elif action == 'push':

            action = '<push/>'

        elif action.startswith('push:'):

            action = '<push state="%s"/>' % action[5:]

        else:

            raise ValueError('unsupported action %r' % (action,))

    else:

        action = '<push state="%s"/>' % action

    return (action,)

def translate_rules(rules):

    out = []

    for rule in rules:

        if isinstance(rule, tuple):

            regex = rule[0]

            if isinstance(regex, str):

                regex = xml_regex(regex)

            elif isinstance(regex, pygments_lexer.words):

                regex = xml_string('%s(%s)%s' % (regex.prefix,

                                      '|'.join(w for w in regex.words),

                                      regex.suffix))

            else:

                raise ValueError('expected regex string but got %r' % regex)

            emitter = resolve_emitter(rule[1])

            if len(rule) == 2:

                modifier = ''

            elif type(rule[2]) is str:

                modifier = process_state_action(rule[2])[0]

            elif isinstance(rule[2], pygments_lexer.combined):

                modifier = '<combined state="%s"/>' % '" state="'.join(rule[2])

            elif type(rule[2]) is tuple:

                modifier = '<push state="%s"/>' % '" state="'.join(rule[2])

            else:

                raise ValueError('unsupported modifier %r' % (rule[2],))

            out.append('<rule pattern={}>{}{}</rule>'.format(regex, emitter, modifier))

        elif isinstance(rule, pygments_lexer.include):

            out.append('<rule><include state="{}"/></rule>'.format(rule))

        elif isinstance(rule, pygments_lexer.default):

            process_state_action(rule.state)

            out.append('<rule>{}</rule>'.format(''.join(process_state_action(rule.state))))

        else:

            raise ValueError('unsupported rule %r' % (rule,))

    return out

class TemplateView(object):

    def __init__(self, **kwargs):

        for key, value in kwargs.items():

            setattr(self, key, value)

    def re_not_multiline(self):

        return not (self.regex_flags & re.MULTILINE)

    def re_dotall(self):

        return self.regex_flags & re.DOTALL

    def re_ignorecase(self):

        return self.regex_flags & re.IGNORECASE

def main():

    package_name, symbol_name = sys.argv[1].rsplit(sep=".", maxsplit=1)

    package = importlib.import_module(package_name)

    lexer_cls = getattr(package, symbol_name)

    assert issubclass(lexer_cls, pygments_lexer.RegexLexer), 'can only translate from RegexLexer'

    print(pystache.render(TEMPLATE, TemplateView(

        name=lexer_cls.name,

        regex_flags=lexer_cls.flags,

        aliases=[{'alias': alias} for alias in lexer_cls.aliases],

        filenames=[{'filename': filename} for filename in lexer_cls.filenames],

        mimetypes=[{'mimetype': mimetype} for mimetype in lexer_cls.mimetypes],

        tokens=[{'state': state, 'rules': translate_rules(rules)} for (state, rules) in lexer_cls.get_tokendefs().items()],

    )))

if __name__ == '__main__':

    main()