import commands, os.path, string, sys, traceback
import color, completer, default, mode, method, regex, tab
import buffer.emul
import window
from point import Point
from lex import Grammar, PatternRule, RegionRule, OverridePatternRule, NocasePatternRule

class CommentGrammar(Grammar): pass
CommentGrammar.rules = [
    RegionRule(r'comment', r'{-', CommentGrammar, r'-}'),
    PatternRule(r'data', r'(?:[^{-]|{(?!-)|-(?!}))+'),
]

class StringGrammar(Grammar):
    rules = [
        RegionRule(r'gap', r'\\ *\n$', Grammar, r'^ *[^ \n]'),
        NocasePatternRule(r'escaped', r'\\(?:NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|[&abfnrtv\\"\']|\^[a-z]|\d{1,3}|o[0-7]{0,3}|x(?:[0-9a-f]){0,2})'),
        PatternRule(r'data', r'[^\\"]+'),
    ]

class HaskellGrammar(Grammar):
    rules = [
        PatternRule(r'comment', r'--(?!>).*$'),
        RegionRule(r'comment', r'{-', CommentGrammar, r'-}'),

        PatternRule(r'integer', r'[0-9]+|0[oO][0-7]+|0[xX][0-7]+'),
        PatternRule(r'float', r'[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+'),
        PatternRule(r'char', r"'[^'\\]'"),
        PatternRule(r'char', r"'(?:[^'\\]|\\(?:NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|[&abfnrtv\\\"\']|\^[a-z]|\d{1,3}|o[0-7]{0,3}|x(?:[0-9a-f]){0,2}))'"),

        PatternRule(r'spaces', r' +'),
        PatternRule(r'eol', r'\n'),
        PatternRule(r'delimiter', r'[\[\](){};]'),

        RegionRule(r'string', r'"', StringGrammar, r'"'),
        PatternRule(r'reserved', r"(?:_|where|type|then|of|newtype|module|let|instance|infixr|infixl|infix|in|import|if|else|do|deriving|default|data|class|case)(?![a-zA-Z0-9_'])"),
        PatternRule(r'hs_declaration', r"^[a-z_][a-zA-Z0-9_']*"),
        PatternRule(r'hs_variable', r"[a-z_][a-zA-Z0-9_']*"),
        PatternRule(r'hs_constructor', r"[A-Z][a-zA-Z0-9_']*"),
        PatternRule(r'hs_operator', r'`[a-z_][a-zA-Z0-9_\']*`'),
        PatternRule(r'operator', r'@|!|>@>|>>=|>>|=>|::|->|;|<-|\\\\|\.\.|!!|:|\+\+|\||\.|\\|>=|>|/=|==|<=|<|\|\||&&|\^\^|\*\*|##|\^|/|\*|-|\+|='),
    ]

class HugsStart(method.shell.Interact):
    args = []
    def _execute(self, w, **vargs):
        method.shell.Interact._execute(self, w, bname='*Hugs*', cmd='hugs')
class HugsLoadFile(method.shell.Interact):
    args = []
    def _execute(self, w, **vargs):
        method.shell.Interact._execute(self, w, bname='*Hugs*', cmd='hugs')
        b = w.application.get_buffer_by_name('*Hugs*')
        path = os.path.realpath(w.buffer.path)
        b.pipe_write(':load "%s"\n' % path)

class HaskellTabber(tab.Tabber):
    pass

class Haskell(mode.Fundamental):
    name        = 'Haskell'
    extensions  = ['.hs']
    tabwidth    = 4
    commentc    = '--'
    #tabbercls  = mode.lisp.LispTabber
    grammar     = HaskellGrammar
    opentokens  = ('delimiter',)
    opentags    = {'(': ')', '{': '}', '[': ']'}
    closetokens = ('delimiter',)
    closetags   = {')': '(', '}': '{', ']': '['}
    colors      = {
        'hs_constructor':   ('magenta', 'default', 'bold'),
        'hs_declaration':   ('blue', 'default', 'bold'),
        'hs_variable':      ('yellow', 'default', 'bold'),
        'hs_operator':      ('cyan', 'default', 'bold'),
        'string.gap.start': ('red', 'default', 'bold'),
        'string.gap.null':  ('red', 'default', 'bold'),
        'string.gap.end':   ('red', 'default', 'bold'),
    }
    _bindings = {
        'close-paren':   (')',),
        'close-brace':   ('}',),
        'close-bracket': (']',),
    }
    actions  = [HugsStart, HugsLoadFile]

install = Haskell.install