import os.path
from subprocess import Popen, PIPE, STDOUT
from method import Method, arg
from method.shell import Exec
from method.tags import InitTags
from mode import Fundamental
import tab
import completer
from lex import Grammar, PatternRule, RegionRule, PatternMatchRule, OverridePatternRule
from mode.python import StringGrammar2
from etags import TagManager

class CommentGrammar(Grammar):
    rules = [
        PatternRule(r'data', r'(?:[^\*]|\*(?!/))+'),
    ]

class ErrorGrammar(Grammar):
    rules = [
        PatternRule(r'data', r'[^\\\n]+'),
        PatternRule('continuation', r'\\\n$'),
    ]

chr1   = '[a-zA-Z_]'
chr2   = '[a-zA-Z0-9_]'
word   = chr1 + chr2 + '*'
spaces = r'[\t ]+'

class MacroGrammar(Grammar):
    rules = [
        PatternRule('continuation', r'\\\n$'),
        PatternRule('name', '(?<=#define ) *' + word),
        PatternRule('name', '(?<=#ifdef ) *' + word),
        PatternRule('name', '(?<=#ifndef ) *' + word),
        PatternRule('name', '(?<=#undef ) *' + word),
        PatternRule('concat', '##' + chr2 + '+'),
        PatternRule('quoted', '#' + chr2 + '+'),
        PatternMatchRule('x', r'(defined)(\()(' + word + r')(\))',
                         'function', 'delimiter', 'name', 'delimiter'),
    ]

class CGrammar(Grammar):
    rules = [
        PatternRule('spaces', spaces),

        PatternMatchRule('x', r'(\()( *)(' + word + r')(\**)( *)(\))( *)(?=[a-zA-Z0-9_\(])',
                         'delimiter', 'spaces', 'c.type', 'c.operator',
                         'spaces', 'delimiter', 'spaces'),

        PatternRule("delimiter", r"\.|\(|\)|\[|\]|{|}|@|,|:|`|;|=(?!=)|\?|->"),
        PatternRule('eol', r"\n$"),
        PatternMatchRule('x', r'(struct|enum|union)( +)(' + word + ')',
                         'c.builtin', 'spaces', 'c.type'),

        PatternRule('c.builtin', r"(?:break|case|continue|default|do|else|for|goto|if|return|sizeof|switch|while)(?!" + chr2 + ")"),
        PatternRule('c.builtin', r"(?:signed|register|extern|const|static|enum|struct|typedef|union|unsigned|volatile)(?!" + chr2 + ")"),
        PatternRule('c.type', r"(?:auto|char|double|float|int|long|short|void|volatile)(?!" + chr2 + ")"),

        PatternMatchRule('x', '(' + word + ')( +)(\**)(' + word + ')( *)(\()',
                         'c.type', 'spaces', 'c.operator', 'c.function',
                         'spaces', 'delimiter'),
        PatternMatchRule('x', '(' + word + ')(\*+)( +)(' + word + ')( *)(\()',
                         'c.type', 'c.operator', 'spaces', 'c.function',
                         'spaces', 'delimiter'),

        PatternMatchRule('x', '(' + word + ')( +)(\**)(' + word + ')',
                         'c.type', 'spaces', 'c.operator', 'c.identifier'),
        PatternMatchRule('x', '(' + word + ')(\*+)( +)(' + word + ')',
                         'c.type', 'c.operator', 'spaces', 'c.identifier'),


        PatternRule('c.function', word + r'(?= *\()'),
        PatternRule('c.constant', "[A-Z_][A-Z0-9_]+(?!" + chr2 + ")"),
        PatternRule('c.label', word + '(?=:)'),
        RegionRule('c.error', '# *error', ErrorGrammar, r'\n$'),
        RegionRule('c.macro', '# *(?:assert|cpu|define|elif|else|endif|error|ident|ifdef|ifndef|if|import|include_next|line|machine|pragma_once|pragma|system|unassert|undef|warning)(?!=' + chr2 + ')', MacroGrammar, r'\n$'),
        RegionRule('c.comment', r'/\*', CommentGrammar, r'\*/'),
        PatternRule('c.comment', '//.*$'),
        RegionRule('c.string', '"', StringGrammar2, '"'),

        PatternRule("c.float", r"-?[0-9]+\.[0-9]*|-?\.[0-9]+|-?(?:[0-9]|[0-9]+\.[0-9]*|-?\.[0-9]+)[eE][\+-]?[0-9]+"),
        PatternRule("c.integer", r"(?:0(?![x0-9])|-?[1-9][0-9]*|0[0-7]+|0[xX][0-9a-fA-F]+)[lL]?"),

        PatternRule("c.operator", r"!(?!=)|\+=|-=|\*=|/=|//=|%=|&=\|\^=|>>=|<<=|\*\*="),
        PatternRule('c.operator', r"\+|<>|<<|<=|<|-|>>|>=|>|\*\*|&&|&|\*|\|\||\||/|\^|==|//|~|!=|%"),
        RegionRule('c.macrocomment', '#if +(?:0|NULL|FALSE)', Grammar, '#endif'),
        PatternMatchRule('', r"(')([^\\])(')", 'c.char.start', 'c.char.data', 'c.char.end'),
        PatternMatchRule('', r"(')(\\.)(')", 'c.char.start', 'c.char.escaped', 'c.char.end'),
        PatternMatchRule('', r"(')(\\[0-7]{3})(')", 'c.char.start', 'c.char.octal', 'c.char.end'),
        PatternMatchRule('', r"(')(\\x[0-9a-fA-F]{2})(')", 'c.char.start', 'c.char.hex', 'c.char.end'),
        #PatternRule('c.char', r"'.'|'\\.'|'\\[0-7]{3}'"),
        PatternMatchRule('x', r'(# *include)( +)(.+)(\n|$)',
                         'c.macro.start', 'spaces', 'c.header', 'c.macro.end'),
        PatternRule('c.identifier', word),
        OverridePatternRule('c.comment', r'/\* *@@:(?P<token>[.a-zA-Z0-9_]+):(?P<mode>[.a-zA-Z0-9_]+) *\*/$'),
        OverridePatternRule('c.comment', r'// *@@:(?P<token>[.a-zA-Z0-9_]+):(?P<mode>[.a-zA-Z0-9_]+) *$'),
    ]

MacroGrammar.rules.extend(CGrammar.rules)

class CTabber2(tab.StackTabber2):
    open_tokens        = {'delimiter': {'{': '}', '(': ')', '[': ']'}}
    close_tokens       = {'delimiter': {'}': '{', ')': '(', ']': '['}}
    # NOTE: we actually need at least two kinds of control tokens:
    # an if/else class, and a do/for/while class. this is so we can get
    # indenting support for else working correctly.
    control_tokens     = {'c.builtin': {'if': 1, 'else': 1, 'while': 1,
                                        'do': 1, 'for': 1}}
    end_at_eof         = False
    end_at_tokens      = {'delimiter': {';': 1}}
    nocontinue_tokens  = {'delimiter': {';': 1, ',': 1}}
    start_free_tokens  = {'c.string.start': 'c.string.end'}
    end_free_tokens    = {'c.string.end': 'c.string.start'}
    start_macro_tokens = {'c.macro.start': 'c.macro.end'}
    end_macro_tokens   = {'c.macro.end': 'c.macro.start'}
    def _is_base(self, y):
        if y == 0:
            return True

        # if there are no tokens we don't really have any info
        tokens = self._get_tokens(y)
        if not tokens:
            return False

        # this assumes that people aren't gonna use these macros inside of
        # blocks, which is probably ok.
        t = tokens[0]
        #if t.fqmatchs('c.macro.start', ('#define', '#include')):
        #    return True

        # detecting function declarations is annoying; this assumes that people
        # won't put a variable type and name on different lines, but that they
        # might do that for function return type and name.
        #
        # unfortunately, valid function return types might include any of the
        # types of tokens below
        decl = False
        for t in tokens:
            if decl and self._is_ignored(t):
                pass
            elif t.isa('c.keyword', 'c.identifier', 'c.type'):
                decl = True
            elif decl and t.name == 'c.function':
                break
            else:
                decl = False
                break
        return decl
    def _is_indent(self, t):
        return t.name == 'spaces'
    def _is_ignored(self, t):
        return t.fqisa('spaces', 'eol', 'c.comment', 'c.comment.start',
                       'c.comment.data', 'c.comment.null', 'c.comment.end')

class CTagManager(TagManager):
    lang  = 'C'
    exts  = set(('.c', '.h'))


class CCheckSyntax(Exec):
    '''Build this C program (using the mode's make cmd)'''
    show_success = False
    args = []
    def _execute(self, w, **vargs):
        cmd='C_INCLUDE_PATH=. %s' % w.application.config['c.syntax-cmd']
        if w.application.config['c.syntax-rel-dir']:
            self._doit(w, w.buffer.path, cmd, cmdname='c-check-syntax',
                       cmddir=os.path.dirname(w.buffer.path))
        else:
            self._doit(w, w.buffer.path, cmd, cmdname='c-check-syntax')

class CMake(Exec):
    '''Build this C program (using the mode's make cmd)'''
    show_success = False
    args = []
    def _execute(self, w, **vargs):
        cmd = w.application.config['c.make-cmd'],
        if w.application.config['c.make-rel-dir']:
            d = os.path.dirname(w.buffer.path)
            self._doit(w, w.buffer.path, cmd, cmdname='c-make', cmddir=d)
        else:
            self._doit(w, w.buffer.path, cmd, cmdname='c-make')

# white is for delimiters, operators, numbers
default = ('default', 'default')

# magenta is for keywords/builtins
lo_magenta = ('magenta202', 'default')
hi_magenta = ('magenta505', 'default')

# red is for comments
lo_red = ('red300', 'default')
hi_red = ('red511', 'default')

# orange is for macro definitions, headers and constants
hi_orange = ('yellow531', 'default')
lo_orange = ('yellow520', 'default')

# yellow is for parts of macros
hi_yellow = ('yellow551', 'default')
lo_yellow = ('yellow330', 'default')

# green is for strings and characters
lo_green = ('green030', 'default')
hi_green = ('green050', 'default')

# cyan is for types
lo_cyan = ('cyan033', 'default')
hi_cyan = ('cyan155', 'default')

# blue is definitions, functions and some macros
lo_blue = ('blue113', 'default')
hi_blue = ('blue225', 'default')

class C(Fundamental):
    name        = 'C'
    extensions  = ['.c', '.h', '.cpp']
    tabbercls   = CTabber2
    tagcls      = CTagManager
    grammar     = CGrammar
    opentokens  = ('delimiter',)
    opentags    = {'(': ')', '[': ']', '{': '}'}
    closetokens = ('delimiter',)
    closetags   = {')': '(', ']': '[', '}': '{'}
    #actions     = [CCheckSyntax, CMake, CInitTags]
    actions     = [CCheckSyntax, CMake]
    format      = "%(flag)s  %(bname)s  (%(mname)s)  %(indent)s  %(cursor)s  %(perc)s  [%(func)s]  %(vc-info)s"
    commentc    = '//'

    colors      = {
        'c.comment':            hi_red,
        'c.comment.start':      hi_red,
        'c.comment.data':       hi_red,
        'c.comment.end':        hi_red,
        'c.macrocomment.start': hi_red,
        'c.macrocomment.null':  hi_red,
        'c.macrocomment.end':   hi_red,

        'c.macro':        hi_yellow,
        'c.macro.start':  hi_yellow,
        'c.macro.name':   hi_orange,
        'c.macro.null':   hi_magenta,
        'c.macro.concat': hi_yellow,
        'c.macro.quoted': hi_green,
        'c.error.start':  hi_blue,
        'c.error.data':   hi_green,

        'c.char.start':   lo_green,
        'c.char.end':     lo_green,
        'c.char.data':    hi_green,
        'c.char.escaped': hi_magenta,
        'c.char.octal':   hi_magenta,
        'c.char.hex':     hi_magenta,

        'c.type':     hi_cyan,
        'c.include':  hi_blue,
        'c.header':   lo_orange,
        'c.constant': hi_orange,

    }
    config = {
        'c.syntax-cmd':     "gcc -x c -fsyntax-only %(path)s",
        'c.syntax-rel-dir': False,
        'c.make-cmd':       "make",
        'c.make-rel-dir':   True,
    }
    lconfig = {
        'ignore_suffix': ['.o'],
    }

    _bindings = {
        'close-paren':    (')',),
        'close-brace':    ('}',),
        'close-bracket':  (']',),
        'c-check-syntax': ('C-c s',),
        'c-make':         ('C-c C-c',),
    }

    def get_functions(self): return {}
    def get_function_names(self): return []
    def get_line_function(self, y): return None
    def get_status_names(self):
        names = Fundamental.get_status_names(self)
        c = self.window.logical_cursor()
        names['func'] = self.get_line_function(c.y)
        return names

install = C.install