import os, re, sets, string, sys
import buffer, color, commands, completer, context, default, method, mode, regex, tab
from point import Point
from lex import Grammar, PatternRule, ContextPatternRule, RegionRule, OverridePatternRule, PatternGroupRule
from method import Argument, Method, WrapParagraph

class PodGrammar(Grammar):
    rules = [
        RegionRule(r'entry', r'(?<=^=head[1-4]) +.*$', Grammar, '^\n$'),
        RegionRule(r'entry', r'(?<=^=over) +.*$', Grammar, '^\n$'),
        RegionRule(r'entry', r'(?<=^=item) +.*$', Grammar, '^\n$'),
        RegionRule(r'entry', r'(?:(?<=^=begin)|(?<=^=end)) +.*$', Grammar, '^\n$'),
        RegionRule(r'entry', r'(?<=^=encoding) +.*$', Grammar, '^\n$'),
    ]

def _make_string_rules(forbidden=None):
    if forbidden:
        rule = PatternRule(r'scalar', r"\$[^A-Za-z0-9 \\%s](?![A-Za-z0-9_])" % forbidden)
    else:
        rule = ContextPatternRule(r'scalar', r"\$[^A-Za-z0-9 %(delim)s](?![A-Za-z0-9_])", r"\$[^A-Za-z0-9 ](?![A-Za-z0-9_])")

    rules = [
        PatternRule(r'octal', r'\\[0-7]{3}'),
        PatternRule(r'escaped', r'\\.'),
        PatternRule(r'deref', r"\$+[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*(?:(?:->)?{\$?(?:[a-zA-Z_][a-zA-Z_0-9]*|'(?:\\.|[^'\\])*'|\"(\\.|[^\\\"])*\")}|(?:->)?\[\$?[0-9a-zA-Z_]+\])+"),
        PatternRule(r'length', r"\$#[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
        rule,
        PatternRule(r'scalar', r"\$\$*[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
        PatternRule(r'cast', r"[\$\@\%\&]{.*?}"),
        PatternRule(r'array', r"@\$*[A-Za-z_](?:[A-Za-z0-9_]|::)*"),
    ]
    return rules

class StrictStringGrammar(Grammar):
    rules = [
        PatternRule(r'escaped', r"\\'"),
    ]
class StringGrammar(Grammar):
    rules = _make_string_rules()

class QuotedGrammar1(Grammar):
    rules = _make_string_rules(')')
class QuotedGrammar2(Grammar):
    rules = _make_string_rules('}')
class QuotedGrammar3(Grammar):
    rules = _make_string_rules('>')
class QuotedGrammar4(Grammar):
    rules = _make_string_rules(']')

class PerlGrammar(Grammar):
    rules = [
        RegionRule(r'heredoc', r"<<(?P<heredoc>[a-zA-Z_][a-zA-Z0-9_]+)", None, ';\n', StringGrammar, r'^%(heredoc)s$'),
        RegionRule(r'heredoc', r'<< *"(?P<heredoc>[a-zA-Z0-9_]+)" *;', StringGrammar, r'^%(heredoc)s$'),
        RegionRule(r'heredoc', r"<< *'(?P<heredoc>[a-zA-Z0-9_]+)' *;", Grammar, r'^%(heredoc)s$'),
        RegionRule(r'evaldoc', r"<< *`(?P<heredoc>[a-zA-Z0-9_]+)` *;", StringGrammar, r'^%(heredoc)s$'),

        RegionRule(r'endblock', r"^__END__|__DATA__ *$", Grammar, r''),
        RegionRule(r'pod', r'^=[a-zA-Z0-9_]+', PodGrammar, r'^=cut'),

        OverridePatternRule(r'comment', r'#@@:(?P<token>[.a-zA-Z0-9_]+):(?P<mode>[.a-zA-Z0-9_]+) *$'),

        #PatternRule(r'prototype', r'\([\\@$%&*;]+\)'),
        PatternGroupRule(r'prototype', r'delimiter', r'\(', r'prototype', r'[\[\]\\@$%&*;]+', r'delimiter', '\)'),

        PatternRule(r'comment', r'#.*$'),
        RegionRule(r'perl_string', r'"', StringGrammar, r'"'),
        RegionRule(r'perl_string', r"'", StrictStringGrammar, r"'"),
        RegionRule(r'evalstring', r"`", StringGrammar, r"`"),
        PatternRule(r'number', r'0?\.[0-9]+|[0-9]+(?:\.[0-9]+)?'),
        PatternRule(r'perl_keyword', r"(?<!->)(?:STDIN|STDERR|STDOUT|continue|do|else|elsif|eval|foreach|for|if|last|my|next|our|package|require|return|sub|undef|unless|until|use|while)(?![a-zA-Z0-9_])"),
        PatternRule(r'hash_key', r'(?<={)[A-Za-z0-9_]+(?=})'),
        PatternRule(r'hash_key', r'[A-Za-z0-9_]+(?= *=>)'),
        PatternRule(r'length', r"\$#[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
        PatternRule(r'cast', r'[\$\@\%\^\&](?= *{)'),
        PatternRule(r'scalar', r"\$[\[\]<>ab/'\"_@\?#\$!%^|&*()](?![A-Za-z0-9_])"),
        PatternRule(r'array', r"@_"),
        PatternRule(r'perl_function', r"\$\$*[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*(?=-> *\()"),
        PatternRule(r'scalar', r"\$\$*[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
        PatternRule(r'array', r"@\$*[A-Za-z_](?:[A-Za-z0-9_]|::)*"),
        PatternRule(r'perl_hash', r"%\$*[A-Za-z_](?:[A-Za-z0-9_]|::)*"),
        PatternRule(r'deref', r"[@%\$&\*](?={)"),

        # match regexes
        RegionRule(r'match', r'(?:(?<==~)|(?<=!~)|(?<=\()|(?<=split)|(?<=if)|(?<=unless)|(?<=while)|(?<=until)) *(?P<delim>/)', StringGrammar, r'/[a-z]*'),
        RegionRule(r'match', r'm *(?P<delim>[^ #a-zA-Z0-9_])', StringGrammar, r'%(delim)s[a-z]*'),
        RegionRule(r'match', r'm(?P<delim>#)', StringGrammar, r'#[a-z]*'),

        # replace regexes
        RegionRule(r'replace', r's *(?P<delim>[^ a-zA-Z0-9_])', StringGrammar, r'%(delim)s', StringGrammar, r'%(delim)s[a-z]*'),
        RegionRule(r'replace', r's(?P<delim>#)', StringGrammar, r'#', StringGrammar, r'#[a-z]*'),

        # translate operator
        RegionRule(r'translate', r'(?:y|tr) *(?P<delim>[^ a-zA-Z0-9_])', Grammar, r'%(delim)s', Grammar, r'%(delim)s[a-z]*'),
        RegionRule(r'translate', r'(?:y|tr)#', Grammar, r'#', Grammar, r'#[a-z]*'),

        # some more basic stuff
        PatternRule(r'package', r"(?<=package )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
        PatternRule(r'sub', r"(?<=sub )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
        PatternRule(r'use', r"(?<=use )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
        PatternRule(r'require', r"(?<=require )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
        PatternRule(r'perl_label', r'[a-zA-Z_][a-zA-Z0-9_]*:(?!:)'),
        PatternRule(r'method', r"(?<=->)[a-zA-Z_][a-zA-Z_0-9]*"),
        PatternRule(r'perl_function', r"&\$*(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
        PatternRule(r'perl_builtin', r"(?<!->)&?(?:write|warn|wantarray|waitpid|wait|vec|values|utime|use|untie|unshift|unpack|unlink|undef|umask|ucfirst|uc|truncate|times|time|tied|tie|telldir|tell|syswrite|system|sysseek|sysread|sysopen|syscall|symlink|substr|sub|study|stat|srand|sqrt|sprintf|split|splice|sort|socketpair|socket|sleep|sin|shutdown|shmwrite|shmread|shmget|shmctl|shift|setsockopt|setservent|setpwent|setprotoent|setpriority|setpgrp|setnetent|sethostent|setgrent|send|semop|semget|semctl|select|seekdir|seek|scalar|rmdir|rindex|rewinddir|reverse|return|reset|require|rename|ref|redo|recv|readpipe|readlink|readline|readdir|read|rand|quotemeta|push|prototype|printf|print|pos|pop|pipe|package|pack|our|ord|opendir|open|oct|no|next|my|msgsnd|msgrcv|msgget|msgctl|mkdir|map|lstat|log|lock|localtime|local|listen|link|length|lcfirst|lc|last|kill|keys|join|ioctl|int|index|import|hex|grep|goto|gmtime|glob|getsockopt|getsockname|getservent|getservbyport|getservbyname|getpwuid|getpwnam|getpwent|getprotoent|getprotobynumber|getprotobyname|getpriority|getppid|getpgrp|getpeername|getnetent|getnetbyname|getnetbyaddr|getlogin|gethostent|gethostbyname|gethostbyaddr|getgrnam|getgrgid|getgrent|getc|formline|format|fork|flock|fileno|fcntl|exp|exit|exists|exec|eval|eof|endservent|endpwent|endprotoent|endnetent|endhostent|endgrent|each|dump|do|die|delete|defined|dbmopen|dbmclose|crypt|cos|continue|connect|closedir|close|chroot|chr|chown|chop|chomp|chmod|chdir|caller|bless|binmode|bind|atan2|alarm|accept|abs)(?![a-zA-Z0-9_])"),

        # quote operator: qq(), qx() and qr() usually interpolate
        RegionRule(r'quoted', r'q[rqx] *(?P<delim>\()', QuotedGrammar1, r'\)'),
        RegionRule(r'quoted', r'q[rqx] *(?P<delim>{)', QuotedGrammar2, r'}'),
        RegionRule(r'quoted', r'q[rqx] *(?P<delim><)', QuotedGrammar3, r'>'),
        RegionRule(r'quoted', r'q[rqx] *(?P<delim>\[)', QuotedGrammar4, r'\]'),
        RegionRule(r'quoted', r"q[rqx] *(?P<delim>')", Grammar, r"'"),
        RegionRule(r'quoted', r'q[rqx] *(?P<delim>[^ #])', StringGrammar, r'%(delim)s'),
        RegionRule(r'quoted', r'q[rqx](?P<delim>#)', StringGrammar, r'#'),

        # quote operator: q() and qw() do not interpolate
        RegionRule(r'quoted', r'qw? *\(', Grammar, r'\)'),
        RegionRule(r'quoted', r'qw? *{', Grammar, r'}'),
        RegionRule(r'quoted', r'qw? *<', Grammar, r'>'),
        RegionRule(r'quoted', r'qw? *\[', Grammar, r'\]'),
        RegionRule(r'quoted', r'qw?#', Grammar, r'#'),
        RegionRule(r'quoted', r'qw? *(?P<delim>[^ #])', Grammar, r'%(delim)s'),

        PatternRule(r'perl_function', r"(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*(?= *\()"),
        PatternRule(r'perl_namespace', r"(?:[a-zA-Z_][a-zA-Z_0-9]*\:\:)+(?:[a-zA-Z_][a-zA-Z_0-9]*)?"),
        PatternRule(r'perl_class', r"(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*(?=->)"),

        # some basic stuff
        PatternRule(r'delimiter', r"::|->|=>|(?<!:):(?!=:)|[,;=\?(){}\[\]\(\)]"),
        PatternRule(r'operator', r"\+=|-=|\*=|/=|//=|%=|&=\|\^=|>>=|<<=|\*\*="),
        PatternRule(r'operator', r"\+\+|\+|<=>|<>|<<|<=|<|-|>>|>=|>|\*\*|\*|&&|&|\|\||\||/|\^|==|//|~|=~|!~|!=|%|!|\.|x(?![a-zA-Z_])"),
        PatternRule(r'noperator', r"(?:xor|or|not|ne|lt|le|gt|ge|eq|cmp|and)(?![a-zA-Z_])"),
        PatternRule(r'bareword', r'(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*'),

        PatternRule(r"eol", r"\n$"),
    ]

class PerlTabber(tab.StackTabber):
    def is_base(self, y):
        if y == 0:
            return True
        highlighter = self.mode.window.buffer.highlights[self.mode.name()]
        if not highlighter.tokens[y]:
            return False
        t = highlighter.tokens[y][0]
        return t.name == 'perl_keyword' and t.string == 'sub'
    def _handle_open_token(self, currlvl, y, i):
        currlvl = tab.StackTabber._handle_open_token(self, currlvl, y, i)
        return currlvl
    def _handle_close_token(self, currlvl, y, i):
        w = self.mode.tabwidth
        self._opt_pop('cont')
        currlvl = tab.StackTabber._handle_close_token(self, currlvl, y, i)
        token = self.get_token(y, i)
        if self.is_rightmost_token(y, i):
            if token.string == '}':
                self._opt_pop('cont')
            else:
                self._opt_append('cont', currlvl + w)
        return currlvl
    def _handle_other_token(self, currlvl, y, i):
        w = self.mode.tabwidth
        token  = self.get_token(y, i)
        fqname = token.fqname()
        if fqname == 'delimiter' and token.string == ';':
            self._opt_pop('cont')
        elif fqname == 'heredoc.start':
            self._opt_append('heredoc', None)
        elif fqname == 'heredoc.end':
            self._opt_pop('heredoc')
            self._opt_pop('cont')
        elif fqname == 'quoted.start':
            self._opt_append('quoted', currlvl + w)
        elif fqname == 'quoted.end':
            self._opt_pop('cont')
            self._opt_pop('quoted')
        elif fqname == 'evaldoc.start':
            self._opt_append('evaldoc', None)
        elif fqname == 'evaldoc.end':
            self._opt_pop('evaldoc')
            self._opt_pop('cont')
        elif fqname == 'pod.start':
            self._opt_append('pod', None)
        elif fqname == 'pod.end':
            self._opt_pop('pod')
            currlvl = 0
        elif fqname == 'perl_string.start':
            self._opt_append('string', None)
        elif fqname == 'perl_string.end':
            self._opt_pop('string')
            if self.is_rightmost_token(y, i):
                self._opt_append('cont', currlvl + w)
        if self.is_rightmost_token(y, i):
            if(not fqname.startswith('pod') and
               not fqname.startswith('heredoc') and
               not fqname.startswith('perl_string') and
               not fqname.startswith('endblock') and
               not fqname == 'eol' and 
               not fqname == 'comment' and
               not fqname == 'null' and
               token.string not in ('}', ';', '(', '{', '[', ',')):
                self._opt_append('cont', currlvl + w)
        return currlvl

class PerlSetLib(Method):
    '''Set the path(s) to find perl modules'''
    args = [Argument("lib", type=type(""), prompt="Location of lib: ",
                            default=default.build_constant("."))]
    def _execute(self, w, **vargs):
        w.application.config['perl.lib'] = vargs['lib']
    
class PerlCheckSyntax(Method):
    '''Check the syntax of a perl file'''
    def _execute(self, w, **vargs):
        app = w.application
        perllib = w.application.config.get('perl.lib')
        if perllib:
            cmd = "perl -c -I '%s' '%s'" % (perllib, w.buffer.path)
        else:
            cmd = "perl -c '%s'" % (w.buffer.path)
        (status, output) = commands.getstatusoutput(cmd)
        if status == 0:
            app.set_error("Syntax OK")
            app.data_buffer("*Perl-Check-Syntax*", output, switch_to=False)
        else:
            app.data_buffer("*Perl-Check-Syntax*", output)

class PerlViewModulePerldoc(Method):
    '''View documentation about this file using perldoc'''
    def _execute(self, w, **vargs):
        cmd = "perldoc -t -T '%s'" % w.buffer.path
        (status, output) = commands.getstatusoutput(cmd)
        w.application.data_buffer("*Perldoc*", output, switch_to=True)

class PerlViewWordPerldoc(Method):
    '''View documentation about a package or function using perldoc'''
    def _try(self, w, word, asfunc=False):
        if asfunc:
            cmd = "perldoc -t -T -f '%s'" % (word,)
        else:
            cmd = "perldoc -t -T '%s'" % (word,)
        perllib = w.application.config.get('perl.lib')
        if perllib:
            cmd = 'PERL5LIB=%r %s' % (perllib, cmd)
        (status, data) = commands.getstatusoutput(cmd)
        if status == 0:
            return data
        else:
            return None
    def _show(self, w, data, word):
        w.application.data_buffer("*Perldoc*", data, switch_to=True)
        w.application.set_error('displaying documentation for %r' % word)
    def _execute(self, w, **vargs):
        token = w.get_token()
        word = token.string

        # make sure that the name is (mostly) valid
        if word is None:
            w.application.set_error('no word selected')
            return
        elif ':' in word and '::' not in word:
            w.application.set_error('invalid word: %r' % word)
            return

        # first try it is a package, unless it's a builtin
        if not token.name == "perl_builtin":
            parts = word.split('::')
            while len(parts) > 0:
                newword = '::'.join(parts)
                data = self._try(w, newword, asfunc=False)
                if data:
                    self._show(w, data, newword)
                    return
                parts.pop(-1)

        # then try it as a function
        data = self._try(w, word, asfunc=True)
        if data:
            self._show(w, data, word)
        else:
            w.application.set_error('nothing found for %r' % word)

class PerlInitFunctions(Method):
    '''Jump to a function defined in this module'''
    def _execute(self, w, **vargs):
        w.mode.context.build_name_map()
        w.application.set_error("Initialized function map")

class PerlGotoFunction(Method):
    '''Jump to a function defined in this module'''
    args = [Argument("name", type(""), "perlfunction", "Goto Function: ")]
    def _execute(self, w, **vargs):
        name = vargs['name']
        functions = w.mode.context.get_names()
        if name in functions:
            w.goto(Point(0, functions[name]))
        else:
            w.application.set_error("Function %r was not found" % name)

class PerlListFunctions(Method):
    '''Show the user all functions defined in this module'''
    def _execute(self, w, **vargs):
        names = w.mode.context.get_name_list()
        output = "\n".join(names) + "\n"
        w.application.data_buffer("*Perl-List-Functions*", output, switch_to=True)

class PerlWhichFunction(Method):
    '''Show the user what function they are in'''
    def _execute(self, w, **vargs):
        cursor = w.logical_cursor()
        name = w.mode.context.get_line_name(cursor.y)
        if name is None:
            w.application.set_error("None");
        else:
            functions = w.mode.context.get_names()
            i = functions[name] + 1
            w.application.set_error("line %d: %s" % (i, name))

class PerlHashCleanup(Method):
    '''Correctly align assignment blocks and literal hashes'''
    def _execute(self, w, **vargs):
        cursor = w.logical_cursor()
        b = w.buffer

        # so this is where we will store the groups that we find
        groups_by_line = {}

        # the regex we will try
        regexes = [regex.perl_hash_cleanup,
                   regex.perl_assign_cleanup]

        # if we aren't in a hash, inform the user and exit
        line = b.lines[cursor.y]
        myregex = None
        for r in regexes:
            if r.match(line):
                myregex = r

        if myregex is None:
            raise Exception, "Not a perl hash line"

        groups_by_line[cursor.y] = myregex.match(line).groups()
        
        # find the beginning of this hash block
        start = 0
        i = cursor.y - 1
        while i >= 0:
            line = b.lines[i]
            m = myregex.match(line)
            if not m:
                start = i + 1
                break
            else:
                groups_by_line[i] = m.groups()
            i -= 1

        # find the end of this hash block
        end = len(b.lines) - 1
        i = cursor.y + 1
        while i < len(b.lines):
            line = b.lines[i]
            m = myregex.match(line)
            if not m:
                end = i - 1
                break
            else:
                groups_by_line[i] = m.groups()
            i += 1
    
        # assume that the least indented line is correct
        indent_w = min([len(groups_by_line[k][0]) for k in groups_by_line])

        # find the longest hash key to base all the other padding on
        key_w = max([len(groups_by_line[k][1]) for k in groups_by_line])

        # for each line, format it correctly
        keys = groups_by_line.keys()
        keys.sort()
        data = ''
        for i in keys:
            indent_pad = ' ' * indent_w
            key = groups_by_line[i][1]
            sep = groups_by_line[i][3]
            value = groups_by_line[i][5]
            key_pad = ' ' * (key_w - len(key))
            data += indent_pad + key + key_pad + ' ' + sep + ' ' + value + '\n'

        # remove the old text and add the new
        start_p = Point(0, start)
        if end < len(w.buffer.lines) - 1:
            end_p = Point(0, end + 1)
        else:
            end_p = Point(len(w.buffer.lines[end]), end)
        w.kill(start_p, end_p)
        w.insert_string(start_p, data)

class PerlWrapParagraph(method.WrapParagraph):
    '''Wrap Comments and POD'''
    # enumerations for line types
    LT_COMMENT = 1
    LT_POD     = 2

    margin     = 80
    comment_re = re.compile('( *)(#+)( *)(.*)')

    def _is_newline(self, t):
        return t.name == 'eol'
    def _is_space(self, t):
        return t.name == 'null' and regex.space.match(t.string)

    def _detect_line_type(self, w, y):
        h = w.buffer.highlights[w.mode.name()]
        ltype = None
        for t in h.tokens[y]:
            fqname = t.fqname()
            if fqname == 'null' or fqname == 'eol':
                pass
            elif fqname.startswith('comment'):
                if ltype and ltype != 'comment':
                    ltype = None
                    break
                ltype = self.LT_COMMENT
            elif fqname.startswith('pod'):
                if ltype and ltype != 'pod':
                    ltype = None
                    break
                ltype = self.LT_POD
            else:
                ltype = None
                break
        return ltype

    def _fix_comments(self, c, w):
        h = w.buffer.highlights[w.mode.name()]
        y1 = c.y
        y2 = c.y
        while y2 < len(w.buffer.lines) - 1:
            if self._detect_line_type(w, y2 + 1):
                y2 += 1
            else:
                break
    
        lines = w.buffer.lines[y1:y2 + 1]
        m = self.comment_re.match(lines[0])
        assert m
        prepend = m.group(1) + m.group(2)
        rmargin = self.margin - len(prepend)
        dpad    = m.group(3)

        segments = []
        for line in lines:
            m = self.comment_re.match(line)
            assert m
            pad, data = m.group(3), m.group(4)
            if segments and pad == dpad and segments[-1][0] == dpad and segments[-1][1]:
                data = segments.pop(-1)[1] + ' ' + data
            i = 0
            while len(pad) + len(data[i:]) > rmargin:
                while data[i] == ' ':
                    i += 1
                j = rmargin - len(pad)
                while j >= 0 and data[i + j] != ' ':
                    j -= 1
                if j < 0:
                    j = rmargin - len(pad)
                segments.append([pad, data[i:i + j]])
                i += j
            if data:
                while data[i] == ' ':
                    i += 1
                segments.append([pad, data[i:]])
            else:
                segments.append(['', ''])

        lines2 = [prepend + x[0] + x[1] for x in segments]
        p1 = Point(0, y1)
        p2 = Point(len(w.buffer.lines[y2]), y2)
        w.buffer.delete(p1, p2)
        w.buffer.insert_lines(p1, lines2)
        w.set_error("wrapped comment lines %d-%d" % (y1 + 1, y2 + 1))

    def _fix_pod(self, c, w):
        w.set_error("pod wrapping not yet supported")

    def _execute(self, w, **vargs):
        c = w.logical_cursor()
        ltype = self._detect_line_type(w, c.y)
        if ltype == self.LT_COMMENT:
            self._fix_comments(c, w)
        elif ltype == self.LT_POD:
            WrapParagraph._execute(self, w, **vargs)
        else:
            w.set_error("did not detect comment or pod lines")

class PerlSemanticComplete(method.introspect.TokenComplete):
    _mini_prompt = 'Semantic Complete'
    def _min_completion(self, w, x1, x2, y):
        a = w.application
        a.methods['iperl-path-start'].execute(w, switch=False)

        name = buffer.IperlBuffer.create_name(w.buffer)
        b = a.get_buffer_by_name(name)

        line = w.buffer.lines[y]
        candidates = b.readline_completions(x1, x2, line)
        if not candidates:
            return ([], line[x1:x2])

        i = 0
        while i < len(candidates[0]):
            for s in candidates:
                if len(s) <= i or s[i] != candidates[0][i]:
                    break
            i += 1
        return (candidates, candidates[0][:i])
    def _execute(self, w, **vargs):
        b = w.buffer
        x2, y = w.logical_cursor().xy()
        if y >= len(b.lines):
            return

        x1 = x2
        while x1 > 0 and b.lines[y][x1 - 1] in "$@%*&abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_:":
            x1 -= 1
        assert x1 >= 0, "%r %r %r" % (x1, x2, len(b.lines[y]))

        (candidates, result) = self._min_completion(w, x1, x2, y)

        if candidates:
            p1 = Point(x1, y)
            p2 = Point(x2, y)
            w.buffer.delete(p1, p2)
            w.insert_string(p1, result)

        if not candidates:
            w.set_error("No completion: %r" % result)
        elif len(candidates) == 1:
            w.set_error("Unique completion: %r" % result)
        elif result in candidates:
            w.set_error("Ambiguous completion: %r" % candidates)
        else:
            w.set_error("Partial completion: %r" % candidates)

class PerlOpenModule(method.Method):
    args = [Argument("module", type=type(""), prompt="Open Perl Module: ")]
    def _execute(self, w, **vargs):
        path = w.mode.find_module(vargs['module'])
        if path:
            w.application.methods['open-file'].execute(w, filename=path)
        else:
            w.set_error("Could not find module %r" % vargs['module'])
class PerlOpenModuleWord(method.Method):
    namechars = string.letters + string.digits + '_'
    def _execute(self, w, **vargs):
        word = pkg = w.get_token().string
        path = None
        while pkg and pkg[0] not in self.namechars:
            pkg = pkg[1:]
        while True:
            path = w.mode.find_module(pkg)
            if path:
                break
            parent = pkg.rsplit('::', 1)[0]
            if parent == pkg:
                break
            else:
                pkg = parent
        if path:
            w.application.methods['open-file'].execute(w, filename=path)
        else:
            w.set_error("Could not find module related to %r" % word)

class PerlFunctionCompleter(completer.Completer):
    def get_candidates(self, s, w=None):
        old_window = w.buffer.method.old_window
        functions = old_window.mode.context.get_names()
        return [n for n in functions if n.startswith(s)]

class PerlContext(context.Context):
    def _regen_stack(self, y):
        if y > 0 and self.namelines[y - 1][1]:
            return list(self.namelines[y - 1][1])
        else:
            return []

    def _build_name_map(self, y1, y2, last, curr, stack):
        blen       = len(self.mode.window.buffer.lines)
        highlights = self.mode.window.get_highlighter()
        i          = y1
        starting   = curr and not bool(stack)
        while i < y2:
            if not starting and not stack:
                curr = None

            g = highlights.tokens[i]
            if (not stack and len(g) > 2 and g[0].name == 'perl_keyword' and
                g[0].string == 'sub' and g[2].name == 'sub'):
                curr     = g[2].string
                starting = True

            if curr is not None and curr not in self.names:
                self.names[curr] = i

            if i == y2 - 1 and curr != self.namelines[i][0] and y2 < blen:
                y2 += 1

            m = self.mode
            for t in g:
                if t.name == 'delimiter' and t.string == '{':
                    stack.append(t.string)
                    starting = False
                elif t.name == 'delimiter' and t.string == '}':
                    if not stack:
                        # we are totally hosed. start over. ugh.
                        self.build_name_map()
                        return
                    stack.pop(-1)
            if curr:
                self.namelines[i] = (curr, tuple(stack))
            i += 1

class Perl(mode.Fundamental):
    modename    = 'Perl'
    extensions  = ['.pl', '.pm']
    detection   = ['perl']
    tabbercls   = PerlTabber
    grammar     = PerlGrammar
    opentokens  = ('delimiter',)
    opentags    = {'(': ')', '[': ']', '{': '}'}
    closetokens = ('delimiter',)
    closetags   = {')': '(', ']': '[', '}': '{'}
    colors      = {
        # comments
        'endblock.start': ('red', 'default', 'bold'),
        'endblock.null':  ('red', 'default', 'bold'),
        'endblock.end':   ('red', 'default', 'bold'),

        # pod
        'pod.start':       ('red', 'default', 'bold'),
        'pod.null':        ('red', 'default', 'bold'),
        'pod.entry.start': ('magenta', 'default', 'bold'),
        'pod.entry.null':  ('magenta', 'default', 'bold'),
        'pod.entry.end':   ('magenta', 'default', 'bold'),
        'pod.end':         ('red', 'default', 'bold'),
        
        # basic stuff
        'escaped':        ('magenta', 'default', 'bold'),
        'null':           ('default', 'default', 'bold'),
        'sub':            ('cyan', 'default', 'bold'),
        'prototype':      ('magenta', 'default', 'bold'),
        'operator':       ('default', 'default', 'bold'),
        'noperator':      ('magenta', 'default', 'bold'),
        'endblock':       ('red', 'default', 'bold'),
        'perl_keyword':   ('magenta', 'default', 'bold'),
        'cast':           ('yellow', 'default', 'bold'),
        'scalar':         ('yellow', 'default', 'bold'),
        'array':          ('yellow', 'default', 'bold'),
        'deref':          ('yellow', 'default', 'bold'),
        'perl_hash':      ('yellow', 'default', 'bold'),
        'hash_key':       ('green', 'default', 'bold'),
        'perl_function':  ('cyan', 'default', 'bold'),
        'perl_namespace': ('cyan', 'default', 'bold'),
        'perl_builtin':   ('magenta', 'default', 'bold'),
        'perl_label':     ('cyan', 'default', 'bold'),
        'package':        ('cyan', 'default', 'bold'),
        'perl_class':     ('cyan', 'default', 'bold'),
        'use':            ('cyan', 'default', 'bold'),
        'require':        ('cyan', 'default', 'bold'),

        # heredoc/evaldoc
        'heredoc.start': ('green', 'default', 'bold'),
        'heredoc.null':  ('green', 'default', 'bold'),
        'heredoc.end':   ('green', 'default', 'bold'),
        'evaldoc.start': ('cyan', 'default', 'bold'),
        'evaldoc.null':  ('cyan', 'default', 'bold'),
        'evaldoc.end':   ('cyan', 'default', 'bold'),
        
        # strings
        'perl_string.start':   ('green', 'default', 'bold'),
        'perl_string.null':    ('green', 'default', 'bold'),
        'perl_string.escaped': ('magenta', 'default', 'bold'),
        'perl_string.deref':   ('yellow', 'default', 'bold'),
        'perl_string.end':     ('green', 'default', 'bold'),
        
        # `` strings
        'evalstring.start':   ('cyan', 'default', 'bold'),
        'evalstring.null':    ('cyan', 'default', 'bold'),
        'evalstring.escaped': ('magenta', 'default', 'bold'),
        'evalstring.deref':   ('yellow', 'default', 'bold'),
        'evalstring.end':     ('cyan', 'default', 'bold'),
        
        # quoted region
        'quoted':         ('cyan', 'default', 'bold'),
        'quoted.start':   ('cyan', 'default', 'bold'),
        'quoted.null':    ('cyan', 'default', 'bold'),
        'quoted.escaped': ('magenta', 'default', 'bold'),
        'quoted.deref':   ('yellow', 'default', 'bold'),
        'quoted.end':     ('cyan', 'default', 'bold'),
        
        # match regex
        'match.start': ('cyan', 'default', 'bold'),
        'match.end':   ('cyan', 'default', 'bold'),
        'match.null':  ('cyan', 'default', 'bold'),
        
        # replace regex
        'replace.start':     ('cyan', 'default', 'bold'),
        'replace.middle0':   ('cyan', 'default', 'bold'),
        'replace.end':       ('cyan', 'default', 'bold'),
        'replace.null':      ('cyan', 'default', 'bold'),
        'replace.escaped':   ('magenta', 'default', 'bold'),
        'replace.deref':     ('yellow', 'default', 'bold'),
        'replace.length':    ('yellow', 'default', 'bold'),
        'replace.scalar':    ('yellow', 'default', 'bold'),
        'replace.perl_hash': ('yellow', 'default', 'bold'),
        'replace.cast':      ('yellow', 'default', 'bold'),
        
        # translate regex
        'translate.start':   ('magenta', 'default', 'bold'),
        'translate.middle0': ('magenta', 'default', 'bold'),
        'translate.end':     ('magenta', 'default', 'bold'),
        'translate.null':    ('magenta', 'default', 'bold'),
    }
    config = {
        'perl.lib': 'lib',
    }
    actions = [PerlSetLib, PerlCheckSyntax, PerlHashCleanup,
               PerlViewModulePerldoc, PerlViewWordPerldoc, PerlWrapParagraph,
               PerlInitFunctions, PerlGotoFunction, PerlWhichFunction,
               PerlListFunctions, PerlOpenModule, PerlOpenModuleWord,
               PerlSemanticComplete]
    completers = {
        'perlfunction': PerlFunctionCompleter(),
    }
    format = "%(flag)s  %(bname)-18s  (%(mname)s)  %(cursor)s/%(mark)s  %(perc)s  [%(func)s]"
    #format = "%(flag)s  %(bname)-18s  (%(mname)s)  %(cursor)s/%(mark)s  %(perc)s"
    def get_status_names(self):
        w = self.window
        c = w.logical_cursor()
        names = {
            'bname':  w.buffer.name(),
            'mname':  self.name(),
            'flag':   self._get_flag(),
            'perc':   self._get_perc(),
            'cursor': '(%d,%d)' % (c.y + 1, c.x + 1),
            'mark':   self._get_mark(),
            'func':   self.get_line_function(c.y),
        }
        return names
    def __init__(self, w):
        mode.Fundamental.__init__(self, w)
        self.add_bindings('perl-set-lib', ('C-c l',))
        self.add_bindings('perl-check-syntax', ('C-c s',))
        self.add_bindings('perl-hash-cleanup', ('C-c h',))
        self.add_bindings('perl-view-module-perldoc', ('C-c v',))
        self.add_bindings('perl-view-word-perldoc', ('C-c p',))
        self.add_bindings('perl-wrap-paragraph', ('M-q',))
        self.add_bindings('perl-goto-function', ('C-c M-g',))
        self.add_bindings('perl-open-module', ('C-c C-f',))
        self.add_bindings('perl-open-module-word', ('C-c M-f',))
        self.add_bindings('perl-semantic-complete', ('C-c TAB',))
        self.add_bindings('close-paren', (')'))
        self.add_bindings('close-bracket', (']'))
        self.add_bindings('close-brace', ('}'))
        self.context   = PerlContext(self)
        self.functions = None
        self.funclines = None

    def find_module(self, module):
        parts = module.split('::')
        parts[-1] += '.pm'
        relpath = os.path.join(*parts)
        path    = None
        for d in self.get_inc():
            path2 = os.path.join(d, relpath)
            if os.path.exists(path2):
                path = path2
                break
        return path

    def get_inc(self):
        a = self.window.application
        a.state.setdefault('perl', {})
        if 'inc' not in a.state['perl']:
            perllib = a.config.get('perl.lib')
            if perllib:
                cmd = "PERL5LIB=%r perl -e 'print join(\"\\n\", @INC);'" % perllib
            else:
                cmd = "perl -e 'print join(\"\\n\", @INC);'"
            (status, data) = commands.getstatusoutput(cmd)
            if status != 0:
                raise Exception, "%r failed" % cmd
            a.state['perl']['inc'] = data.split('\n')
        return a.state['perl']['inc']

    def get_functions(self):
        return self.context.get_names()
    def get_function_names(self):
        return self.context.get_name_list()
    def get_line_function(self, y):
        return self.context.get_line_name(y)

install = Perl.install